Fix clippy warnings

node/collation-generation/src/tests.rs

@@ -353,7 +353,7 @@ mod handle_new_activations {
 				let expect_descriptor = {
 					let mut expect_descriptor = expect_descriptor;
 					expect_descriptor.signature = descriptor.signature.clone();
-					expect_descriptor.erasure_root = descriptor.erasure_root.clone();
+					expect_descriptor.erasure_root = descriptor.erasure_root;
 					expect_descriptor
 				};
 				assert_eq!(descriptor, expect_descriptor);

node/core/av-store/src/tests.rs

@@ -53,7 +53,7 @@ struct TestClock {
 
 impl TestClock {
 	fn now(&self) -> Duration {
-		self.inner.lock().clone()
+		*self.inner.lock()
 	}
 
 	fn inc(&self, by: Duration) {

node/core/backing/src/tests.rs

@@ -283,7 +283,6 @@ fn backing_second_works() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 
@@ -373,7 +372,6 @@ fn backing_works() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 
@@ -522,7 +520,6 @@ fn backing_works_while_validation_ongoing() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 
@@ -699,7 +696,6 @@ fn backing_misbehavior_works() {
 			pov_hash,
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
 			head_data: expected_head_data.clone(),
-			..Default::default()
 		}
 		.build();
 
@@ -884,7 +880,6 @@ fn backing_dont_second_invalid() {
 			pov_hash: pov_hash_b,
 			erasure_root: make_erasure_root(&test_state, pov_block_b.clone()),
 			head_data: expected_head_data.clone(),
-			..Default::default()
 		}
 		.build();
 
@@ -1215,7 +1210,6 @@ fn backing_doesnt_second_wrong_collator() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 
@@ -1267,7 +1261,6 @@ fn validation_work_ignores_wrong_collator() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 
@@ -1541,7 +1534,6 @@ fn observes_backing_even_if_not_validator() {
 			pov_hash,
 			head_data: expected_head_data.clone(),
 			erasure_root: make_erasure_root(&test_state, pov.clone()),
-			..Default::default()
 		}
 		.build();
 

node/core/chain-selection/src/tests.rs

@@ -568,7 +568,7 @@ fn assert_backend_contains<'a>(
 
 fn assert_backend_contains_chains(backend: &TestBackend, chains: Vec<Vec<(Header, BlockWeight)>>) {
 	for chain in chains {
-		assert_backend_contains(backend, chain.iter().map(|&(ref hdr, _)| hdr))
+		assert_backend_contains(backend, chain.iter().map(|(hdr, _)| hdr))
 	}
 }
 
@@ -688,7 +688,7 @@ fn import_chain_on_finalized_incrementally() {
 		.await;
 
 		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 1);
-		assert_backend_contains(&backend, chain.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![head_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![head_hash]).await;
 
@@ -721,8 +721,8 @@ fn import_two_subtrees_on_finalized() {
 		import_blocks_into(&mut virtual_overseer, &backend, None, chain_b.clone()).await;
 
 		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 1);
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![b_hash, a_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![b_hash, a_hash]).await;
 
@@ -755,8 +755,8 @@ fn import_two_subtrees_on_nonzero_finalized() {
 		import_blocks_into(&mut virtual_overseer, &backend, None, chain_b.clone()).await;
 
 		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 101);
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![b_hash, a_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![b_hash, a_hash]).await;
 
@@ -799,9 +799,9 @@ fn leaves_ordered_by_weight_and_then_number() {
 		.await;
 
 		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 1);
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_c.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_c.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![c2_hash, a3_hash, b2_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![c2_hash, a3_hash, b2_hash]).await;
 		virtual_overseer
@@ -844,8 +844,8 @@ fn subtrees_imported_even_with_gaps() {
 		.await;
 
 		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 1);
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![b5_hash, a3_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![b5_hash, a3_hash]).await;
 
@@ -878,7 +878,7 @@ fn reversion_removes_viability_of_chain() {
 		)
 		.await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![]);
 		assert_finalized_leaves_query(&mut virtual_overseer, finalized_number, finalized_hash)
 			.await;
@@ -914,7 +914,7 @@ fn reversion_removes_viability_and_finds_ancestor_as_leaf() {
 		)
 		.await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![a1_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![a1_hash]).await;
 
@@ -954,15 +954,15 @@ fn ancestor_of_unviable_is_not_leaf_if_has_children() {
 
 		import_blocks_into(&mut virtual_overseer, &backend, None, chain_b.clone()).await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![a2_hash, b2_hash]);
 
 		import_blocks_into(&mut virtual_overseer, &backend, None, chain_a_ext.clone()).await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_a_ext.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_a_ext.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![b2_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![b2_hash]).await;
 
@@ -995,7 +995,7 @@ fn self_and_future_reversions_are_ignored() {
 		)
 		.await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![a3_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![a3_hash]).await;
 
@@ -1028,7 +1028,7 @@ fn revert_finalized_is_ignored() {
 		)
 		.await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![a3_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![a3_hash]).await;
 
@@ -1072,8 +1072,8 @@ fn reversion_affects_viability_of_all_subtrees() {
 
 		import_blocks_into(&mut virtual_overseer, &backend, None, chain_b.clone()).await;
 
-		assert_backend_contains(&backend, chain_a.iter().map(|&(ref h, _)| h));
-		assert_backend_contains(&backend, chain_b.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, chain_a.iter().map(|(h, _)| h));
+		assert_backend_contains(&backend, chain_b.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![a1_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![a1_hash]).await;
 
@@ -2034,12 +2034,12 @@ fn revert_blocks_message_triggers_proper_reversion() {
 		.await;
 
 		// Checking mini chain
-		assert_backend_contains(&backend, built_chain.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, built_chain.iter().map(|(h, _)| h));
 		assert_leaves(&backend, vec![head_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![head_hash]).await;
 
-		let block_1_hash = backend.load_blocks_by_number(1).unwrap().get(0).unwrap().clone();
-		let block_2_hash = backend.load_blocks_by_number(2).unwrap().get(0).unwrap().clone();
+		let block_1_hash = *backend.load_blocks_by_number(1).unwrap().get(0).unwrap();
+		let block_2_hash = *backend.load_blocks_by_number(2).unwrap().get(0).unwrap();
 
 		// Sending revert blocks message
 		let (_, write_rx) = backend.await_next_write();
@@ -2098,7 +2098,7 @@ fn revert_blocks_against_finalized_is_ignored() {
 		.await;
 
 		// Checking mini chain
-		assert_backend_contains(&backend, built_chain.iter().map(|&(ref h, _)| h));
+		assert_backend_contains(&backend, built_chain.iter().map(|(h, _)| h));
 
 		// Sending dispute concluded against message
 		virtual_overseer

node/core/dispute-coordinator/src/participation/queues/tests.rs

@@ -44,7 +44,7 @@ fn make_dummy_comparator(
 fn clone_request(request: &ParticipationRequest) -> ParticipationRequest {
 	ParticipationRequest {
 		candidate_receipt: request.candidate_receipt.clone(),
-		candidate_hash: request.candidate_hash.clone(),
+		candidate_hash: request.candidate_hash,
 		session: request.session,
 		request_timer: None,
 	}

node/core/dispute-coordinator/src/tests.rs

@@ -399,10 +399,10 @@ impl TestState {
 					let mut response = Vec::new();
 					for i in target_header.number.saturating_sub(k as u32)..target_header.number {
 						response.push(
-							self.block_num_to_header
+							*self
+								.block_num_to_header
 								.get(&i)
-								.expect("headers and block_num_to_header should always be in sync")
-								.clone(),
+								.expect("headers and block_num_to_header should always be in sync"),
 						);
 					}
 					let _ = response_channel.send(Ok(response));
@@ -552,7 +552,7 @@ impl TestState {
 		let (ctx, ctx_handle) = make_buffered_subsystem_context(TaskExecutor::new(), 1);
 		let subsystem = DisputeCoordinatorSubsystem::new(
 			self.db.clone(),
-			self.config.clone(),
+			self.config,
 			self.subsystem_keystore.clone(),
 			Metrics::default(),
 		);
@@ -574,27 +574,27 @@ where
 
 	// Add two more blocks after the genesis (which is created in `default()`)
 	let h1 = Header {
-		parent_hash: test_state.last_block.clone(),
+		parent_hash: test_state.last_block,
 		number: 1,
 		digest: dummy_digest(),
 		state_root: dummy_hash(),
 		extrinsics_root: dummy_hash(),
 	};
 	let h1_hash = h1.hash();
-	test_state.headers.insert(h1_hash.clone(), h1);
-	test_state.block_num_to_header.insert(1, h1_hash.clone());
+	test_state.headers.insert(h1_hash, h1);
+	test_state.block_num_to_header.insert(1, h1_hash);
 	test_state.last_block = h1_hash;
 
 	let h2 = Header {
-		parent_hash: test_state.last_block.clone(),
+		parent_hash: test_state.last_block,
 		number: 2,
 		digest: dummy_digest(),
 		state_root: dummy_hash(),
 		extrinsics_root: dummy_hash(),
 	};
 	let h2_hash = h2.hash();
-	test_state.headers.insert(h2_hash.clone(), h2);
-	test_state.block_num_to_header.insert(2, h2_hash.clone());
+	test_state.headers.insert(h2_hash, h2);
+	test_state.block_num_to_header.insert(2, h2_hash);
 	test_state.last_block = h2_hash;
 
 	test_state.resume(test)
@@ -3133,7 +3133,7 @@ fn participation_requests_reprioritized_for_newly_included() {
 				// participation.
 				let parent_block_num: BlockNumber = repetition as BlockNumber - 1;
 				candidate_receipt.descriptor.relay_parent =
-					test_state.block_num_to_header.get(&parent_block_num).unwrap().clone();
+					*test_state.block_num_to_header.get(&parent_block_num).unwrap();
 				receipts.push(candidate_receipt.clone());
 			}