Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base * Second run * Add CI check * Fix compilation * More unnecessary braces * Handle weights * Use --all * Use correct attributes... * Fix UI tests * AHHHHHHHHH * 🤦 * Docs * Fix compilation * 🤷 * Please stop * 🤦 x 2 * More * make rustfmt.toml consistent with polkadot Co-authored-by: André Silva <andrerfosilva@gmail.com>
2026-04-27 05:47:58 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -16,13 +16,15 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-use std::cmp;
-use std::ops::Range;
-use std::collections::{HashMap, BTreeMap};
-use log::trace;
-use libp2p::PeerId;
-use sp_runtime::traits::{Block as BlockT, NumberFor, One};
 use crate::protocol::message;
+use libp2p::PeerId;
+use log::trace;
+use sp_runtime::traits::{Block as BlockT, NumberFor, One};
+use std::{
+	cmp,
+	collections::{BTreeMap, HashMap},
+	ops::Range,
+};

 /// Block data with origin.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -35,10 +37,7 @@ pub struct BlockData<B: BlockT> {

 #[derive(Debug)]
 enum BlockRangeState<B: BlockT> {
-	Downloading {
-		len: NumberFor<B>,
-		downloading: u32,
-	},
+	Downloading { len: NumberFor<B>, downloading: u32 },
 	Complete(Vec<BlockData<B>>),
 }

@@ -62,10 +61,7 @@ pub struct BlockCollection<B: BlockT> {
 impl<B: BlockT> BlockCollection<B> {
 	/// Create a new instance.
 	pub fn new() -> Self {
-		BlockCollection {
-			blocks: BTreeMap::new(),
-			peer_requests: HashMap::new(),
-		}
+		BlockCollection { blocks: BTreeMap::new(), peer_requests: HashMap::new() }
 	}

 	/// Clear everything.
@@ -77,7 +73,7 @@ impl<B: BlockT> BlockCollection<B> {
 	/// Insert a set of blocks into collection.
 	pub fn insert(&mut self, start: NumberFor<B>, blocks: Vec<message::BlockData<B>>, who: PeerId) {
 		if blocks.is_empty() {
-			return;
+			return
 		}

 		match self.blocks.get(&start) {
@@ -86,13 +82,20 @@ impl<B: BlockT> BlockCollection<B> {
 			},
 			Some(&BlockRangeState::Complete(ref existing)) if existing.len() >= blocks.len() => {
 				trace!(target: "sync", "Ignored block data already downloaded: {}", start);
-				return;
+				return
 			},
 			_ => (),
 		}

-		self.blocks.insert(start, BlockRangeState::Complete(blocks.into_iter()
-			.map(|b| BlockData { origin: Some(who.clone()), block: b }).collect()));
+		self.blocks.insert(
+			start,
+			BlockRangeState::Complete(
+				blocks
+					.into_iter()
+					.map(|b| BlockData { origin: Some(who.clone()), block: b })
+					.collect(),
+			),
+		);
 	}

 	/// Returns a set of block hashes that require a header download. The returned set is marked as being downloaded.
@@ -107,7 +110,7 @@ impl<B: BlockT> BlockCollection<B> {
 	) -> Option<Range<NumberFor<B>>> {
 		if peer_best <= common {
 			// Bail out early
-			return None;
+			return None
 		}
 		// First block number that we need to download
 		let first_different = common + <NumberFor<B>>::one();
@@ -120,15 +123,13 @@ impl<B: BlockT> BlockCollection<B> {
 				break match (prev, next) {
 					(Some((start, &BlockRangeState::Downloading { ref len, downloading })), _)
 						if downloading < max_parallel =>
-						(*start .. *start + *len, downloading),
+						(*start..*start + *len, downloading),
 					(Some((start, r)), Some((next_start, _))) if *start + r.len() < *next_start =>
-						(*start + r.len() .. cmp::min(*next_start, *start + r.len() + count), 0), // gap
-					(Some((start, r)), None) =>
-						(*start + r.len() .. *start + r.len() + count, 0), // last range
-					(None, None) =>
-						(first_different .. first_different + count, 0), // empty
+						(*start + r.len()..cmp::min(*next_start, *start + r.len() + count), 0), // gap
+					(Some((start, r)), None) => (*start + r.len()..*start + r.len() + count, 0), /* last range */
+					(None, None) => (first_different..first_different + count, 0),               /* empty */
 					(None, Some((start, _))) if *start > first_different =>
-						(first_different .. cmp::min(first_different + count, *start), 0), // gap at the start
+						(first_different..cmp::min(first_different + count, *start), 0), /* gap at the start */
 					_ => {
 						prev = next;
 						continue
@@ -139,23 +140,33 @@ impl<B: BlockT> BlockCollection<B> {
 		// crop to peers best
 		if range.start > peer_best {
 			trace!(target: "sync", "Out of range for peer {} ({} vs {})", who, range.start, peer_best);
-			return None;
+			return None
 		}
 		range.end = cmp::min(peer_best + One::one(), range.end);

-		if self.blocks.iter().next().map_or(false, |(n, _)| range.start > *n + max_ahead.into()) {
+		if self
+			.blocks
+			.iter()
+			.next()
+			.map_or(false, |(n, _)| range.start > *n + max_ahead.into())
+		{
 			trace!(target: "sync", "Too far ahead for peer {} ({})", who, range.start);
-			return None;
+			return None
 		}

 		self.peer_requests.insert(who, range.start);
-		self.blocks.insert(range.start, BlockRangeState::Downloading {
-			len: range.end - range.start,
-			downloading: downloading + 1
-		});
+		self.blocks.insert(
+			range.start,
+			BlockRangeState::Downloading {
+				len: range.end - range.start,
+				downloading: downloading + 1,
+			},
+		);
 		if range.end <= range.start {
-			panic!("Empty range {:?}, count={}, peer_best={}, common={}, blocks={:?}",
-				range, count, peer_best, common, self.blocks);
+			panic!(
+				"Empty range {:?}, count={}, peer_best={}, common={}, blocks={:?}",
+				range, count, peer_best, common, self.blocks
+			);
 		}
 		Some(range)
 	}
@@ -188,16 +199,14 @@ impl<B: BlockT> BlockCollection<B> {
 	pub fn clear_peer_download(&mut self, who: &PeerId) {
 		if let Some(start) = self.peer_requests.remove(who) {
 			let remove = match self.blocks.get_mut(&start) {
-				Some(&mut BlockRangeState::Downloading { ref mut downloading, .. }) if *downloading > 1 => {
+				Some(&mut BlockRangeState::Downloading { ref mut downloading, .. })
+					if *downloading > 1 =>
+				{
 					*downloading -= 1;
 					false
-				},
-				Some(&mut BlockRangeState::Downloading { .. }) => {
-					true
-				},
-				_ => {
-					false
 				}
+				Some(&mut BlockRangeState::Downloading { .. }) => true,
+				_ => false,
 			};
 			if remove {
 				self.blocks.remove(&start);
@@ -210,27 +219,28 @@ impl<B: BlockT> BlockCollection<B> {
 mod test {
 	use super::{BlockCollection, BlockData, BlockRangeState};
 	use crate::{protocol::message, PeerId};
-	use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
 	use sp_core::H256;
+	use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};

 	type Block = RawBlock<ExtrinsicWrapper<u64>>;

 	fn is_empty(bc: &BlockCollection<Block>) -> bool {
-		bc.blocks.is_empty() &&
-		bc.peer_requests.is_empty()
+		bc.blocks.is_empty() && bc.peer_requests.is_empty()
 	}

 	fn generate_blocks(n: usize) -> Vec<message::BlockData<Block>> {
-		(0 .. n).map(|_| message::generic::BlockData {
-			hash: H256::random(),
-			header: None,
-			body: None,
-			indexed_body: None,
-			message_queue: None,
-			receipt: None,
-			justification: None,
-			justifications: None,
-		}).collect()
+		(0..n)
+			.map(|_| message::generic::BlockData {
+				hash: H256::random(),
+				header: None,
+				body: None,
+				indexed_body: None,
+				message_queue: None,
+				receipt: None,
+				justification: None,
+				justifications: None,
+			})
+			.collect()
 	}

 	#[test]
@@ -252,32 +262,47 @@ mod test {
 		let peer2 = PeerId::random();

 		let blocks = generate_blocks(150);
-		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(1 .. 41));
-		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(41 .. 81));
-		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 0, 1, 200), Some(81 .. 121));
+		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(1..41));
+		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(41..81));
+		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 0, 1, 200), Some(81..121));

 		bc.clear_peer_download(&peer1);
 		bc.insert(41, blocks[41..81].to_vec(), peer1.clone());
 		assert_eq!(bc.drain(1), vec![]);
-		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(121 .. 151));
+		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(121..151));
 		bc.clear_peer_download(&peer0);
 		bc.insert(1, blocks[1..11].to_vec(), peer0.clone());

-		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(11 .. 41));
-		assert_eq!(bc.drain(1), blocks[1..11].iter()
-			.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) }).collect::<Vec<_>>());
+		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(11..41));
+		assert_eq!(
+			bc.drain(1),
+			blocks[1..11]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) })
+				.collect::<Vec<_>>()
+		);

 		bc.clear_peer_download(&peer0);
 		bc.insert(11, blocks[11..41].to_vec(), peer0.clone());

 		let drained = bc.drain(12);
-		assert_eq!(drained[..30], blocks[11..41].iter()
-			.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) }).collect::<Vec<_>>()[..]);
-		assert_eq!(drained[30..], blocks[41..81].iter()
-			.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) }).collect::<Vec<_>>()[..]);
+		assert_eq!(
+			drained[..30],
+			blocks[11..41]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) })
+				.collect::<Vec<_>>()[..]
+		);
+		assert_eq!(
+			drained[30..],
+			blocks[41..81]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) })
+				.collect::<Vec<_>>()[..]
+		);

 		bc.clear_peer_download(&peer2);
-		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 80, 1, 200), Some(81 .. 121));
+		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 80, 1, 200), Some(81..121));
 		bc.clear_peer_download(&peer2);
 		bc.insert(81, blocks[81..121].to_vec(), peer2.clone());
 		bc.clear_peer_download(&peer1);
@@ -285,25 +310,38 @@ mod test {

 		assert_eq!(bc.drain(80), vec![]);
 		let drained = bc.drain(81);
-		assert_eq!(drained[..40], blocks[81..121].iter()
-			.map(|b| BlockData { block: b.clone(), origin: Some(peer2.clone()) }).collect::<Vec<_>>()[..]);
-		assert_eq!(drained[40..], blocks[121..150].iter()
-			.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) }).collect::<Vec<_>>()[..]);
+		assert_eq!(
+			drained[..40],
+			blocks[81..121]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer2.clone()) })
+				.collect::<Vec<_>>()[..]
+		);
+		assert_eq!(
+			drained[40..],
+			blocks[121..150]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) })
+				.collect::<Vec<_>>()[..]
+		);
 	}

 	#[test]
 	fn large_gap() {
 		let mut bc: BlockCollection<Block> = BlockCollection::new();
-		bc.blocks.insert(100, BlockRangeState::Downloading {
-			len: 128,
-			downloading: 1,
-		});
-		let blocks = generate_blocks(10).into_iter().map(|b| BlockData { block: b, origin: None }).collect();
+		bc.blocks.insert(100, BlockRangeState::Downloading { len: 128, downloading: 1 });
+		let blocks = generate_blocks(10)
+			.into_iter()
+			.map(|b| BlockData { block: b, origin: None })
+			.collect();
 		bc.blocks.insert(114305, BlockRangeState::Complete(blocks));

 		let peer0 = PeerId::random();
-		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 000, 1, 200), Some(1 .. 100));
+		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 000, 1, 200), Some(1..100));
 		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 600, 1, 200), None); // too far ahead
-		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 600, 1, 200000), Some(100 + 128 .. 100 + 128 + 128));
+		assert_eq!(
+			bc.needed_blocks(peer0.clone(), 128, 10000, 600, 1, 200000),
+			Some(100 + 128..100 + 128 + 128)
+		);
 	}
 }
@@ -16,14 +16,16 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-use sp_blockchain::Error as ClientError;
 use crate::protocol::sync::{PeerSync, PeerSyncState};
 use fork_tree::ForkTree;
 use libp2p::PeerId;
 use log::{debug, trace, warn};
+use sp_blockchain::Error as ClientError;
 use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
-use std::collections::{HashMap, HashSet, VecDeque};
-use std::time::Duration;
+use std::{
+	collections::{HashMap, HashSet, VecDeque},
+	time::Duration,
+};
 use wasm_timer::Instant;

 // Time to wait before trying to get the same extra data from the same peer.
@@ -61,7 +63,7 @@ pub(crate) struct Metrics {
 	pub(crate) active_requests: u32,
 	pub(crate) importing_requests: u32,
 	pub(crate) failed_requests: u32,
-	_priv: ()
+	_priv: (),
 }

 impl<B: BlockT> ExtraRequests<B> {
@@ -93,13 +95,14 @@ impl<B: BlockT> ExtraRequests<B> {

 	/// Queue an extra data request to be considered by the `Matcher`.
 	pub(crate) fn schedule<F>(&mut self, request: ExtraRequest<B>, is_descendent_of: F)
-		where F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>
+	where
+		F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>,
 	{
 		match self.tree.import(request.0, request.1, (), &is_descendent_of) {
 			Ok(true) => {
 				// this is a new root so we add it to the current `pending_requests`
 				self.pending_requests.push_back((request.0, request.1));
-			}
+			},
 			Err(fork_tree::Error::Revert) => {
 				// we have finalized further than the given request, presumably
 				// by some other part of the system (not sync). we can safely
@@ -107,8 +110,8 @@ impl<B: BlockT> ExtraRequests<B> {
 			},
 			Err(err) => {
 				debug!(target: "sync", "Failed to insert request {:?} into tree: {:?}", request, err);
-			}
-			_ => ()
+			},
+			_ => (),
 		}
 	}

@@ -120,7 +123,11 @@ impl<B: BlockT> ExtraRequests<B> {
 	}

 	/// Processes the response for the request previously sent to the given peer.
-	pub(crate) fn on_response<R>(&mut self, who: PeerId, resp: Option<R>) -> Option<(PeerId, B::Hash, NumberFor<B>, R)> {
+	pub(crate) fn on_response<R>(
+		&mut self,
+		who: PeerId,
+		resp: Option<R>,
+	) -> Option<(PeerId, B::Hash, NumberFor<B>, R)> {
 		// we assume that the request maps to the given response, this is
 		// currently enforced by the outer network protocol before passing on
 		// messages to chain sync.
@@ -157,9 +164,10 @@ impl<B: BlockT> ExtraRequests<B> {
 		&mut self,
 		best_finalized_hash: &B::Hash,
 		best_finalized_number: NumberFor<B>,
-		is_descendent_of: F
+		is_descendent_of: F,
 	) -> Result<(), fork_tree::Error<ClientError>>
-		where F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>
+	where
+		F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>,
 	{
 		let request = (*best_finalized_hash, best_finalized_number);

@@ -203,9 +211,8 @@ impl<B: BlockT> ExtraRequests<B> {
 		&mut self,
 		request: ExtraRequest<B>,
 		result: Result<ExtraRequest<B>, E>,
-		reschedule_on_failure: bool
-	) -> bool
-	{
+		reschedule_on_failure: bool,
+	) -> bool {
 		if !self.importing_requests.remove(&request) {
 			return false
 		}
@@ -217,7 +224,7 @@ impl<B: BlockT> ExtraRequests<B> {
 					self.pending_requests.push_front(request);
 				}
 				return true
-			}
+			},
 		};

 		if self.tree.finalize_root(&finalized_hash).is_none() {
@@ -258,7 +265,7 @@ impl<B: BlockT> ExtraRequests<B> {
 			active_requests: self.active_requests.len().try_into().unwrap_or(std::u32::MAX),
 			failed_requests: self.failed_requests.len().try_into().unwrap_or(std::u32::MAX),
 			importing_requests: self.importing_requests.len().try_into().unwrap_or(std::u32::MAX),
-			_priv: ()
+			_priv: (),
 		}
 	}
 }
@@ -269,15 +276,12 @@ pub(crate) struct Matcher<'a, B: BlockT> {
 	/// Length of pending requests collection.
 	/// Used to ensure we do not loop more than once over all pending requests.
 	remaining: usize,
-	extras: &'a mut ExtraRequests<B>
+	extras: &'a mut ExtraRequests<B>,
 }

 impl<'a, B: BlockT> Matcher<'a, B> {
 	fn new(extras: &'a mut ExtraRequests<B>) -> Self {
-		Matcher {
-			remaining: extras.pending_requests.len(),
-			extras
-		}
+		Matcher { remaining: extras.pending_requests.len(), extras }
 	}

 	/// Finds a peer to which a pending request can be sent.
@@ -294,7 +298,10 @@ impl<'a, B: BlockT> Matcher<'a, B> {
 	///
 	/// The returned `PeerId` (if any) is guaranteed to come from the given `peers`
 	/// argument.
-	pub(crate) fn next(&mut self, peers: &HashMap<PeerId, PeerSync<B>>) -> Option<(PeerId, ExtraRequest<B>)> {
+	pub(crate) fn next(
+		&mut self,
+		peers: &HashMap<PeerId, PeerSync<B>>,
+	) -> Option<(PeerId, ExtraRequest<B>)> {
 		if self.remaining == 0 {
 			return None
 		}
@@ -305,7 +312,9 @@ impl<'a, B: BlockT> Matcher<'a, B> {
 		}

 		while let Some(request) = self.extras.pending_requests.pop_front() {
-			for (peer, sync) in peers.iter().filter(|(_, sync)| sync.state == PeerSyncState::Available) {
+			for (peer, sync) in
+				peers.iter().filter(|(_, sync)| sync.state == PeerSyncState::Available)
+			{
 				// only ask peers that have synced at least up to the block number that we're asking the extra for
 				if sync.best_number < request.1 {
 					continue
@@ -315,7 +324,13 @@ impl<'a, B: BlockT> Matcher<'a, B> {
 					continue
 				}
 				// only ask if the same request has not failed for this peer before
-				if self.extras.failed_requests.get(&request).map(|rr| rr.iter().any(|i| &i.0 == peer)).unwrap_or(false) {
+				if self
+					.extras
+					.failed_requests
+					.get(&request)
+					.map(|rr| rr.iter().any(|i| &i.0 == peer))
+					.unwrap_or(false)
+				{
 					continue
 				}
 				self.extras.active_requests.insert(peer.clone(), request);
@@ -343,22 +358,22 @@ impl<'a, B: BlockT> Matcher<'a, B> {

 #[cfg(test)]
 mod tests {
-	use crate::protocol::sync::PeerSync;
-	use sp_blockchain::Error as ClientError;
-	use quickcheck::{Arbitrary, Gen, QuickCheck};
-	use std::collections::{HashMap, HashSet};
 	use super::*;
+	use crate::protocol::sync::PeerSync;
+	use quickcheck::{Arbitrary, Gen, QuickCheck};
+	use sp_blockchain::Error as ClientError;
 	use sp_test_primitives::{Block, BlockNumber, Hash};
+	use std::collections::{HashMap, HashSet};

 	#[test]
 	fn requests_are_processed_in_order() {
 		fn property(mut peers: ArbitraryPeers) {
 			let mut requests = ExtraRequests::<Block>::new("test");

-			let num_peers_available = peers.0.values()
-				.filter(|s| s.state == PeerSyncState::Available).count();
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();

-			for i in 0 .. num_peers_available {
+			for i in 0..num_peers_available {
 				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
 			}

@@ -368,12 +383,12 @@ mod tests {
 			for p in &pending {
 				let (peer, r) = m.next(&peers.0).unwrap();
 				assert_eq!(p, &r);
-				peers.0.get_mut(&peer).unwrap().state = PeerSyncState::DownloadingJustification(r.0);
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
 			}
 		}

-		QuickCheck::new()
-			.quickcheck(property as fn(ArbitraryPeers))
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers))
 	}

 	#[test]
@@ -398,22 +413,24 @@ mod tests {
 		fn property(mut peers: ArbitraryPeers) -> bool {
 			let mut requests = ExtraRequests::<Block>::new("test");

-			let num_peers_available = peers.0.values()
-				.filter(|s| s.state == PeerSyncState::Available).count();
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();

-			for i in 0 .. num_peers_available {
+			for i in 0..num_peers_available {
 				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
 			}

 			let mut m = requests.matcher();
 			while let Some((peer, r)) = m.next(&peers.0) {
-				peers.0.get_mut(&peer).unwrap().state = PeerSyncState::DownloadingJustification(r.0);
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
 			}

 			assert!(requests.pending_requests.is_empty());

 			let active_peers = requests.active_requests.keys().cloned().collect::<Vec<_>>();
-			let previously_active = requests.active_requests.values().cloned().collect::<HashSet<_>>();
+			let previously_active =
+				requests.active_requests.values().cloned().collect::<HashSet<_>>();

 			for peer in &active_peers {
 				requests.peer_disconnected(peer)
@@ -424,8 +441,7 @@ mod tests {
 			previously_active == requests.pending_requests.iter().cloned().collect::<HashSet<_>>()
 		}

-		QuickCheck::new()
-			.quickcheck(property as fn(ArbitraryPeers) -> bool)
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers) -> bool)
 	}

 	#[test]
@@ -433,31 +449,44 @@ mod tests {
 		fn property(mut peers: ArbitraryPeers) {
 			let mut requests = ExtraRequests::<Block>::new("test");

-			let num_peers_available = peers.0.values()
-				.filter(|s| s.state == PeerSyncState::Available).count();
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();

-			for i in 0 .. num_peers_available {
+			for i in 0..num_peers_available {
 				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
 			}

 			let mut m = requests.matcher();
 			while let Some((peer, r)) = m.next(&peers.0) {
-				peers.0.get_mut(&peer).unwrap().state = PeerSyncState::DownloadingJustification(r.0);
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
 			}

-			let active = requests.active_requests.iter().map(|(p, &r)| (p.clone(), r)).collect::<Vec<_>>();
+			let active = requests
+				.active_requests
+				.iter()
+				.map(|(p, &r)| (p.clone(), r))
+				.collect::<Vec<_>>();

 			for (peer, req) in &active {
 				assert!(requests.failed_requests.get(req).is_none());
 				assert!(!requests.pending_requests.contains(req));
 				assert!(requests.on_response::<()>(peer.clone(), None).is_none());
 				assert!(requests.pending_requests.contains(req));
-				assert_eq!(1, requests.failed_requests.get(req).unwrap().iter().filter(|(p, _)| p == peer).count())
+				assert_eq!(
+					1,
+					requests
+						.failed_requests
+						.get(req)
+						.unwrap()
+						.iter()
+						.filter(|(p, _)| p == peer)
+						.count()
+				)
 			}
 		}

-		QuickCheck::new()
-			.quickcheck(property as fn(ArbitraryPeers))
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers))
 	}

 	#[test]
@@ -497,7 +526,10 @@ mod tests {
 		finality_proofs.try_finalize_root::<()>((hash6, 6), Ok((hash7, 7)), true);

 		// ensure that there's no request for #6
-		assert_eq!(finality_proofs.pending_requests.iter().collect::<Vec<_>>(), Vec::<&(Hash, u64)>::new());
+		assert_eq!(
+			finality_proofs.pending_requests.iter().collect::<Vec<_>>(),
+			Vec::<&(Hash, u64)>::new()
+		);
 	}

 	#[test]
@@ -560,7 +592,7 @@ mod tests {
 	impl Arbitrary for ArbitraryPeers {
 		fn arbitrary(g: &mut Gen) -> Self {
 			let mut peers = HashMap::with_capacity(g.size());
-			for _ in 0 .. g.size() {
+			for _ in 0..g.size() {
 				let ps = ArbitraryPeerSync::arbitrary(g).0;
 				peers.insert(ps.peer_id.clone(), ps);
 			}
@@ -16,13 +16,15 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-use std::sync::Arc;
-use codec::{Encode, Decode};
-use sp_runtime::traits::{Block as BlockT, Header, NumberFor};
-use sc_client_api::StorageProof;
-use crate::schema::v1::{StateRequest, StateResponse, StateEntry};
-use crate::chain::{Client, ImportedState};
 use super::StateDownloadProgress;
+use crate::{
+	chain::{Client, ImportedState},
+	schema::v1::{StateEntry, StateRequest, StateResponse},
+};
+use codec::{Decode, Encode};
+use sc_client_api::StorageProof;
+use sp_runtime::traits::{Block as BlockT, Header, NumberFor};
+use std::sync::Arc;

 /// State sync support.

@@ -73,14 +75,14 @@ impl<B: BlockT> StateSync<B> {
 				target: "sync",
 				"Bad state response",
 			);
-			return ImportResult::BadResponse;
+			return ImportResult::BadResponse
 		}
 		if !self.skip_proof && response.proof.is_empty() {
 			log::debug!(
 				target: "sync",
 				"Missing proof",
 			);
-			return ImportResult::BadResponse;
+			return ImportResult::BadResponse
 		}
 		let complete = if !self.skip_proof {
 			log::debug!(
@@ -93,24 +95,21 @@ impl<B: BlockT> StateSync<B> {
 				Ok(proof) => proof,
 				Err(e) => {
 					log::debug!(target: "sync", "Error decoding proof: {:?}", e);
-					return ImportResult::BadResponse;
-				}
-			};
-			let (values, complete) = match self.client.verify_range_proof(
-				self.target_root,
-				proof,
-				&self.last_key
-			) {
-				Err(e) => {
-					log::debug!(
-						target: "sync",
-						"StateResponse failed proof verification: {:?}",
-						e,
-					);
-					return ImportResult::BadResponse;
+					return ImportResult::BadResponse
 				},
-				Ok(values) => values,
 			};
+			let (values, complete) =
+				match self.client.verify_range_proof(self.target_root, proof, &self.last_key) {
+					Err(e) => {
+						log::debug!(
+							target: "sync",
+							"StateResponse failed proof verification: {:?}",
+							e,
+						);
+						return ImportResult::BadResponse
+					},
+					Ok(values) => values,
+				};
 			log::debug!(target: "sync", "Imported with {} keys", values.len());

 			if let Some(last) = values.last().map(|(k, _)| k) {
@@ -120,7 +119,7 @@ impl<B: BlockT> StateSync<B> {
 			for (key, value) in values {
 				self.imported_bytes += key.len() as u64;
 				self.state.push((key, value))
-			};
+			}
 			self.imported_bytes += proof_size;
 			complete
 		} else {
@@ -142,10 +141,14 @@ impl<B: BlockT> StateSync<B> {
 		};
 		if complete {
 			self.complete = true;
-			ImportResult::Import(self.target_block.clone(), self.target_header.clone(), ImportedState {
-				block: self.target_block.clone(),
-				state: std::mem::take(&mut self.state)
-			})
+			ImportResult::Import(
+				self.target_block.clone(),
+				self.target_header.clone(),
+				ImportedState {
+					block: self.target_block.clone(),
+					state: std::mem::take(&mut self.state),
+				},
+			)
 		} else {
 			ImportResult::Continue(self.next_request())
 		}
@@ -178,10 +181,6 @@ impl<B: BlockT> StateSync<B> {
 	/// Returns state sync estimated progress.
 	pub fn progress(&self) -> StateDownloadProgress {
 		let percent_done = (*self.last_key.get(0).unwrap_or(&0u8) as u32) * 100 / 256;
-		StateDownloadProgress {
-			percentage: percent_done,
-			size: self.imported_bytes,
-		}
+		StateDownloadProgress { percentage: percent_done, size: self.imported_bytes }
 	}
 }
-