Mass replace ,); pattern (#3580)

This is an artifact left by rustfmt which is not dare to remove the
comma being conservative.

polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs

@@ -524,7 +524,7 @@ fn force_approve_works() {
 		.unwrap()
 		.approved_bitfield
 		.not_any());
-	assert_eq!(approved_hashes, vec![block_hash_b, block_hash_a],);
+	assert_eq!(approved_hashes, vec![block_hash_b, block_hash_a]);
 }
 
 #[test]

polkadot/node/core/approval-voting/src/import.rs

@@ -502,7 +502,7 @@ pub(crate) async fn handle_new_head(
 		};
 
 		if let Some(up_to) = force_approve {
-			tracing::debug!(target: LOG_TARGET, ?block_hash, up_to, "Enacting force-approve",);
+			tracing::debug!(target: LOG_TARGET, ?block_hash, up_to, "Enacting force-approve");
 
 			let approved_hashes = crate::ops::force_approve(db, block_hash, up_to)
 				.map_err(|e| SubsystemError::with_origin("approval-voting", e))?;

polkadot/node/core/approval-voting/src/lib.rs

@@ -960,7 +960,7 @@ fn distribution_messages_for_activation(
 		let block_entry = match db.load_block_entry(&block_hash)? {
 			Some(b) => b,
 			None => {
-				tracing::warn!(target: LOG_TARGET, ?block_hash, "Missing block entry",);
+				tracing::warn!(target: LOG_TARGET, ?block_hash, "Missing block entry");
 
 				continue
 			},
@@ -2222,7 +2222,7 @@ async fn launch_approval(
 				// Validation checked out. Issue an approval command. If the underlying service is unreachable,
 				// then there isn't anything we can do.
 
-				tracing::trace!(target: LOG_TARGET, ?candidate_hash, ?para_id, "Candidate Valid",);
+				tracing::trace!(target: LOG_TARGET, ?candidate_hash, ?para_id, "Candidate Valid");
 
 				let expected_commitments_hash = candidate.commitments_hash;
 				if commitments.hash() == expected_commitments_hash {

polkadot/node/core/av-store/src/lib.rs

@@ -707,7 +707,7 @@ fn note_block_backed(
 ) -> Result<(), Error> {
 	let candidate_hash = candidate.hash();
 
-	tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Candidate backed",);
+	tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Candidate backed");
 
 	if load_meta(db, config, &candidate_hash)?.is_none() {
 		let meta = CandidateMeta {
@@ -748,7 +748,7 @@ fn note_block_included(
 		Some(mut meta) => {
 			let be_block = (BEBlockNumber(block.0), block.1);
 
-			tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Candidate included",);
+			tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Candidate included");
 
 			meta.state = match meta.state {
 				State::Unavailable(at) => {
@@ -1194,7 +1194,7 @@ fn store_available_data(
 
 	subsystem.db.write(tx)?;
 
-	tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Stored data and chunks",);
+	tracing::debug!(target: LOG_TARGET, ?candidate_hash, "Stored data and chunks");
 
 	Ok(())
 }

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

@@ -720,7 +720,7 @@ fn stored_data_kept_until_finalized() {
 		test_state.wait_for_pruning().await;
 
 		// At this point data should be gone from the store.
-		assert!(query_available_data(&mut virtual_overseer, candidate_hash).await.is_none(),);
+		assert!(query_available_data(&mut virtual_overseer, candidate_hash).await.is_none());
 
 		assert!(has_all_chunks(&mut virtual_overseer, candidate_hash, n_validators, false).await);
 		virtual_overseer
@@ -964,9 +964,9 @@ fn forkfullness_works() {
 			available_data_2,
 		);
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, true).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, true).await);
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, true).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, true).await);
 
 		// Candidate 2 should now be considered unavailable and will be pruned.
 		test_state.clock.inc(test_state.pruning_config.keep_unavailable_for);
@@ -977,24 +977,24 @@ fn forkfullness_works() {
 			available_data_1,
 		);
 
-		assert!(query_available_data(&mut virtual_overseer, candidate_2_hash).await.is_none(),);
+		assert!(query_available_data(&mut virtual_overseer, candidate_2_hash).await.is_none());
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, true).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, true).await);
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, false).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, false).await);
 
 		// Wait for longer than finalized blocks should be kept for
 		test_state.clock.inc(test_state.pruning_config.keep_finalized_for);
 		test_state.wait_for_pruning().await;
 
 		// Everything should be pruned now.
-		assert!(query_available_data(&mut virtual_overseer, candidate_1_hash).await.is_none(),);
+		assert!(query_available_data(&mut virtual_overseer, candidate_1_hash).await.is_none());
 
-		assert!(query_available_data(&mut virtual_overseer, candidate_2_hash).await.is_none(),);
+		assert!(query_available_data(&mut virtual_overseer, candidate_2_hash).await.is_none());
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, false).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_1_hash, n_validators, false).await);
 
-		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, false).await,);
+		assert!(has_all_chunks(&mut virtual_overseer, candidate_2_hash, n_validators, false).await);
 		virtual_overseer
 	});
 }

polkadot/node/core/chain-selection/src/db_backend/v1.rs

@@ -481,7 +481,7 @@ mod tests {
 			.write(vec![BackendWriteOp::DeleteBlockEntry(block_entry.block_hash)])
 			.unwrap();
 
-		assert!(backend.load_block_entry(&block_entry.block_hash).unwrap().is_none(),);
+		assert!(backend.load_block_entry(&block_entry.block_hash).unwrap().is_none());
 	}
 
 	#[test]
@@ -491,7 +491,7 @@ mod tests {
 
 		let mut backend = DbBackend::new(db, config);
 
-		assert!(backend.load_first_block_number().unwrap().is_none(),);
+		assert!(backend.load_first_block_number().unwrap().is_none());
 
 		backend
 			.write(vec![
@@ -501,7 +501,7 @@ mod tests {
 			])
 			.unwrap();
 
-		assert_eq!(backend.load_first_block_number().unwrap(), Some(2),);
+		assert_eq!(backend.load_first_block_number().unwrap(), Some(2));
 
 		backend
 			.write(vec![
@@ -510,7 +510,7 @@ mod tests {
 			])
 			.unwrap();
 
-		assert_eq!(backend.load_first_block_number().unwrap(), Some(10),);
+		assert_eq!(backend.load_first_block_number().unwrap(), Some(10));
 	}
 
 	#[test]
@@ -521,7 +521,7 @@ mod tests {
 		let mut backend = DbBackend::new(db, config);
 
 		// Prove that it's cheap
-		assert!(backend.load_stagnant_at_up_to(Timestamp::max_value()).unwrap().is_empty(),);
+		assert!(backend.load_stagnant_at_up_to(Timestamp::max_value()).unwrap().is_empty());
 
 		backend
 			.write(vec![
@@ -584,9 +584,9 @@ mod tests {
 			])
 			.unwrap();
 
-		assert_eq!(backend.load_blocks_by_number(2).unwrap(), vec![Hash::repeat_byte(1)],);
+		assert_eq!(backend.load_blocks_by_number(2).unwrap(), vec![Hash::repeat_byte(1)]);
 
-		assert_eq!(backend.load_blocks_by_number(3).unwrap(), vec![],);
+		assert_eq!(backend.load_blocks_by_number(3).unwrap(), vec![]);
 
 		backend
 			.write(vec![
@@ -595,10 +595,10 @@ mod tests {
 			])
 			.unwrap();
 
-		assert_eq!(backend.load_blocks_by_number(2).unwrap(), vec![],);
+		assert_eq!(backend.load_blocks_by_number(2).unwrap(), vec![]);
 
-		assert_eq!(backend.load_blocks_by_number(5).unwrap(), vec![],);
+		assert_eq!(backend.load_blocks_by_number(5).unwrap(), vec![]);
 
-		assert_eq!(backend.load_blocks_by_number(10).unwrap(), vec![Hash::repeat_byte(3)],);
+		assert_eq!(backend.load_blocks_by_number(10).unwrap(), vec![Hash::repeat_byte(3)]);
 	}
 }

polkadot/node/core/chain-selection/src/lib.rs

@@ -497,7 +497,7 @@ async fn handle_active_leaf(
 
 	let header = match fetch_header(ctx, hash).await? {
 		None => {
-			tracing::warn!(target: LOG_TARGET, ?hash, "Missing header for new head",);
+			tracing::warn!(target: LOG_TARGET, ?hash, "Missing header for new head");
 			return Ok(Vec::new())
 		},
 		Some(h) => h,

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

@@ -551,7 +551,7 @@ fn assert_backend_contains<'a>(
 			header.number,
 			hash,
 		);
-		assert!(backend.load_block_entry(&hash).unwrap().is_some(), "no entry found for {}", hash,);
+		assert!(backend.load_block_entry(&hash).unwrap().is_some(), "no entry found for {}", hash);
 	}
 }
 
@@ -1138,9 +1138,9 @@ fn finalize_viable_prunes_subtrees() {
 		assert_leaves(&backend, vec![a3_hash, x3_hash]);
 		assert_leaves_query(&mut virtual_overseer, vec![a3_hash, x3_hash]).await;
 
-		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 3,);
+		assert_eq!(backend.load_first_block_number().unwrap().unwrap(), 3);
 
-		assert_eq!(backend.load_blocks_by_number(3).unwrap(), vec![a3_hash, x3_hash],);
+		assert_eq!(backend.load_blocks_by_number(3).unwrap(), vec![a3_hash, x3_hash]);
 
 		virtual_overseer
 	});

polkadot/node/core/dispute-coordinator/src/db/v1.rs

@@ -304,7 +304,7 @@ mod tests {
 		);
 
 		// Test that overlay returns the correct values before committing.
-		assert_eq!(overlay_db.load_earliest_session().unwrap().unwrap(), 1,);
+		assert_eq!(overlay_db.load_earliest_session().unwrap().unwrap(), 1);
 
 		assert_eq!(
 			overlay_db.load_recent_disputes().unwrap().unwrap(),
@@ -328,7 +328,7 @@ mod tests {
 		backend.write(write_ops).unwrap();
 
 		// Test that subsequent writes were written.
-		assert_eq!(backend.load_earliest_session().unwrap().unwrap(), 1,);
+		assert_eq!(backend.load_earliest_session().unwrap().unwrap(), 1);
 
 		assert_eq!(
 			backend.load_recent_disputes().unwrap().unwrap(),
@@ -457,7 +457,7 @@ mod tests {
 		let mut overlay_db = OverlayedBackend::new(&backend);
 		note_current_session(&mut overlay_db, current_session).unwrap();
 
-		assert_eq!(overlay_db.load_earliest_session().unwrap(), Some(new_earliest_session),);
+		assert_eq!(overlay_db.load_earliest_session().unwrap(), Some(new_earliest_session));
 
 		assert_eq!(
 			overlay_db.load_recent_disputes().unwrap().unwrap(),

polkadot/node/core/dispute-coordinator/src/lib.rs

@@ -498,7 +498,7 @@ async fn handle_new_activations(
 			Ok(SessionWindowUpdate::Advanced { new_window_end: window_end, .. }) => {
 				let session = window_end;
 				if state.highest_session.map_or(true, |s| s < session) {
-					tracing::trace!(target: LOG_TARGET, session, "Observed new session. Pruning",);
+					tracing::trace!(target: LOG_TARGET, session, "Observed new session. Pruning");
 
 					state.highest_session = Some(session);
 

polkadot/node/core/pvf/src/execute/queue.rs

@@ -258,7 +258,7 @@ async fn spawn_worker_task(program_path: PathBuf, spawn_timeout: Duration) -> Qu
 		match super::worker::spawn(&program_path, spawn_timeout).await {
 			Ok((idle, handle)) => break QueueEvent::Spawn((idle, handle)),
 			Err(err) => {
-				tracing::warn!(target: LOG_TARGET, "failed to spawn an execute worker: {:?}", err,);
+				tracing::warn!(target: LOG_TARGET, "failed to spawn an execute worker: {:?}", err);
 
 				// Assume that the failure intermittent and retry after a delay.
 				Delay::new(Duration::from_secs(3)).await;

polkadot/node/core/pvf/src/prepare/pool.rs

@@ -241,7 +241,7 @@ async fn spawn_worker_task(program_path: PathBuf, spawn_timeout: Duration) -> Po
 		match worker::spawn(&program_path, spawn_timeout).await {
 			Ok((idle, handle)) => break PoolEvent::Spawn(idle, handle),
 			Err(err) => {
-				tracing::warn!(target: LOG_TARGET, "failed to spawn a prepare worker: {:?}", err,);
+				tracing::warn!(target: LOG_TARGET, "failed to spawn a prepare worker: {:?}", err);
 
 				// Assume that the failure intermittent and retry after a delay.
 				Delay::new(Duration::from_secs(3)).await;

polkadot/node/core/pvf/src/prepare/worker.rs

@@ -262,7 +262,7 @@ fn renice(pid: u32, niceness: i32) {
 	unsafe {
 		if -1 == libc::setpriority(libc::PRIO_PROCESS, pid, niceness) {
 			let err = std::io::Error::last_os_error();
-			tracing::warn!(target: LOG_TARGET, "failed to set the priority: {:?}", err,);
+			tracing::warn!(target: LOG_TARGET, "failed to set the priority: {:?}", err);
 		}
 	}
 }

polkadot/node/core/runtime-api/src/tests.rs

@@ -368,7 +368,7 @@ fn requests_check_validation_outputs() {
 				),
 			})
 			.await;
-		assert_eq!(rx.await.unwrap().unwrap(), runtime_api.validation_outputs_results[&para_a],);
+		assert_eq!(rx.await.unwrap().unwrap(), runtime_api.validation_outputs_results[&para_a]);
 
 		let (tx, rx) = oneshot::channel();
 		ctx_handle
@@ -379,7 +379,7 @@ fn requests_check_validation_outputs() {
 				),
 			})
 			.await;
-		assert_eq!(rx.await.unwrap().unwrap(), runtime_api.validation_outputs_results[&para_b],);
+		assert_eq!(rx.await.unwrap().unwrap(), runtime_api.validation_outputs_results[&para_b]);
 
 		ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
 	};
@@ -664,7 +664,7 @@ fn requests_inbound_hrmp_channels_contents() {
 				),
 			})
 			.await;
-		assert_eq!(rx.await.unwrap().unwrap(), para_b_inbound_channels,);
+		assert_eq!(rx.await.unwrap().unwrap(), para_b_inbound_channels);
 
 		ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
 	};

polkadot/node/network/approval-distribution/src/lib.rs

@@ -200,11 +200,11 @@ impl State {
 		match event {
 			NetworkBridgeEvent::PeerConnected(peer_id, role, _) => {
 				// insert a blank view if none already present
-				tracing::trace!(target: LOG_TARGET, ?peer_id, ?role, "Peer connected",);
+				tracing::trace!(target: LOG_TARGET, ?peer_id, ?role, "Peer connected");
 				self.peer_views.entry(peer_id).or_default();
 			},
 			NetworkBridgeEvent::PeerDisconnected(peer_id) => {
-				tracing::trace!(target: LOG_TARGET, ?peer_id, "Peer disconnected",);
+				tracing::trace!(target: LOG_TARGET, ?peer_id, "Peer disconnected");
 				self.peer_views.remove(&peer_id);
 				self.blocks.iter_mut().for_each(|(_hash, entry)| {
 					entry.known_by.remove(&peer_id);
@@ -224,7 +224,7 @@ impl State {
 				self.handle_peer_view_change(ctx, metrics, peer_id, view).await;
 			},
 			NetworkBridgeEvent::OurViewChange(view) => {
-				tracing::trace!(target: LOG_TARGET, ?view, "Own view change",);
+				tracing::trace!(target: LOG_TARGET, ?view, "Own view change");
 				for head in view.iter() {
 					if !self.blocks.contains_key(head) {
 						self.pending_known.entry(*head).or_default();
@@ -454,7 +454,7 @@ impl State {
 		peer_id: PeerId,
 		view: View,
 	) {
-		tracing::trace!(target: LOG_TARGET, ?view, "Peer view change",);
+		tracing::trace!(target: LOG_TARGET, ?view, "Peer view change");
 		let finalized_number = view.finalized_number;
 		let old_view = self.peer_views.insert(peer_id.clone(), view.clone());
 		let old_finalized_number = old_view.map(|v| v.finalized_number).unwrap_or(0);
@@ -570,7 +570,7 @@ impl State {
 			if entry.knowledge.known_messages.contains(&fingerprint) {
 				modify_reputation(ctx, peer_id.clone(), BENEFIT_VALID_MESSAGE).await;
 				if let Some(peer_knowledge) = entry.known_by.get_mut(&peer_id) {
-					tracing::trace!(target: LOG_TARGET, ?peer_id, ?fingerprint, "Known assignment",);
+					tracing::trace!(target: LOG_TARGET, ?peer_id, ?fingerprint, "Known assignment");
 					peer_knowledge.received.insert(fingerprint.clone());
 				}
 				return
@@ -589,7 +589,7 @@ impl State {
 			let result = match rx.await {
 				Ok(result) => result,
 				Err(_) => {
-					tracing::debug!(target: LOG_TARGET, "The approval voting subsystem is down",);
+					tracing::debug!(target: LOG_TARGET, "The approval voting subsystem is down");
 					return
 				},
 			};
@@ -805,7 +805,7 @@ impl State {
 
 			// if the approval is known to be valid, reward the peer
 			if entry.knowledge.contains(&fingerprint) {
-				tracing::trace!(target: LOG_TARGET, ?peer_id, ?fingerprint, "Known approval",);
+				tracing::trace!(target: LOG_TARGET, ?peer_id, ?fingerprint, "Known approval");
 				modify_reputation(ctx, peer_id.clone(), BENEFIT_VALID_MESSAGE).await;
 				if let Some(peer_knowledge) = entry.known_by.get_mut(&peer_id) {
 					peer_knowledge.received.insert(fingerprint.clone());
@@ -822,7 +822,7 @@ impl State {
 			let result = match rx.await {
 				Ok(result) => result,
 				Err(_) => {
-					tracing::debug!(target: LOG_TARGET, "The approval voting subsystem is down",);
+					tracing::debug!(target: LOG_TARGET, "The approval voting subsystem is down");
 					return
 				},
 			};
@@ -978,7 +978,7 @@ impl State {
 			);
 
 		if !lucky {
-			tracing::trace!(target: LOG_TARGET, ?peer_id, "Unlucky peer",);
+			tracing::trace!(target: LOG_TARGET, ?peer_id, "Unlucky peer");
 			return
 		}
 

polkadot/node/network/approval-distribution/src/tests.rs

@@ -77,7 +77,7 @@ async fn overseer_send(overseer: &mut VirtualOverseer, msg: ApprovalDistribution
 }
 
 async fn overseer_signal_block_finalized(overseer: &mut VirtualOverseer, number: BlockNumber) {
-	tracing::trace!(?number, "Sending a finalized signal",);
+	tracing::trace!(?number, "Sending a finalized signal");
 	// we don't care about the block hash
 	overseer
 		.send(FromOverseer::Signal(OverseerSignal::BlockFinalized(Hash::zero(), number)))
@@ -249,7 +249,7 @@ fn try_import_the_same_assignment() {
 		expect_reputation_change(overseer, &peer_d, COST_UNEXPECTED_MESSAGE).await;
 		expect_reputation_change(overseer, &peer_d, BENEFIT_VALID_MESSAGE).await;
 
-		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent",);
+		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent");
 		virtual_overseer
 	});
 }
@@ -405,7 +405,7 @@ fn peer_sending_us_the_same_we_just_sent_them_is_ok() {
 		let msg = protocol_v1::ApprovalDistributionMessage::Assignments(assignments);
 		send_message_from_peer(overseer, peer, msg.clone()).await;
 
-		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "we should not punish the peer",);
+		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "we should not punish the peer");
 
 		// send the assignments again
 		send_message_from_peer(overseer, peer, msg).await;
@@ -860,7 +860,7 @@ fn import_remotely_then_locally() {
 		)
 		.await;
 
-		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent",);
+		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent");
 
 		// send the approval remotely
 		let approval = IndirectSignedApprovalVote {
@@ -887,7 +887,7 @@ fn import_remotely_then_locally() {
 		// import the same approval locally
 		overseer_send(overseer, ApprovalDistributionMessage::DistributeApproval(approval)).await;
 
-		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent",);
+		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent");
 		virtual_overseer
 	});
 }
@@ -966,7 +966,7 @@ fn sends_assignments_even_when_state_is_approved() {
 			}
 		);
 
-		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent",);
+		assert!(overseer.recv().timeout(TIMEOUT).await.is_none(), "no message should be sent");
 		virtual_overseer
 	});
 }

polkadot/node/network/availability-recovery/src/lib.rs

@@ -723,7 +723,7 @@ where
 			launch_interaction(state, ctx, session_info, receipt, backing_group, response_sender)
 				.await,
 		None => {
-			tracing::warn!(target: LOG_TARGET, "SessionInfo is `None` at {:?}", state.live_block,);
+			tracing::warn!(target: LOG_TARGET, "SessionInfo is `None` at {:?}", state.live_block);
 			response_sender
 				.send(Err(RecoveryError::Unavailable))
 				.map_err(|_| error::Error::CanceledResponseSender)?;

polkadot/node/network/bitfield-distribution/src/lib.rs

@@ -460,7 +460,7 @@ async fn process_incoming_peer_message<Context>(
 	if !received_set.contains(&validator) {
 		received_set.insert(validator.clone());
 	} else {
-		tracing::trace!(target: LOG_TARGET, ?validator_index, ?origin, "Duplicate message",);
+		tracing::trace!(target: LOG_TARGET, ?validator_index, ?origin, "Duplicate message");
 		modify_reputation(ctx, origin, COST_PEER_DUPLICATE_MESSAGE).await;
 		return
 	};
@@ -512,12 +512,12 @@ async fn handle_network_msg<Context>(
 
 	match bridge_message {
 		NetworkBridgeEvent::PeerConnected(peerid, role, _) => {
-			tracing::trace!(target: LOG_TARGET, ?peerid, ?role, "Peer connected",);
+			tracing::trace!(target: LOG_TARGET, ?peerid, ?role, "Peer connected");
 			// insert if none already present
 			state.peer_views.entry(peerid).or_default();
 		},
 		NetworkBridgeEvent::PeerDisconnected(peerid) => {
-			tracing::trace!(target: LOG_TARGET, ?peerid, "Peer disconnected",);
+			tracing::trace!(target: LOG_TARGET, ?peerid, "Peer disconnected");
 			// get rid of superfluous data
 			state.peer_views.remove(&peerid);
 		},
@@ -531,11 +531,11 @@ async fn handle_network_msg<Context>(
 			}
 		},
 		NetworkBridgeEvent::PeerViewChange(peerid, view) => {
-			tracing::trace!(target: LOG_TARGET, ?peerid, ?view, "Peer view change",);
+			tracing::trace!(target: LOG_TARGET, ?peerid, ?view, "Peer view change");
 			handle_peer_view_change(ctx, state, peerid, view).await;
 		},
 		NetworkBridgeEvent::OurViewChange(view) => {
-			tracing::trace!(target: LOG_TARGET, ?view, "Our view change",);
+			tracing::trace!(target: LOG_TARGET, ?view, "Our view change");
 			handle_our_view_change(state, view);
 		},
 		NetworkBridgeEvent::PeerMessage(remote, message) =>
@@ -589,7 +589,7 @@ async fn handle_peer_view_change<Context>(
 		);
 
 	if !lucky {
-		tracing::trace!(target: LOG_TARGET, ?origin, "Peer view change is ignored",);
+		tracing::trace!(target: LOG_TARGET, ?origin, "Peer view change is ignored");
 		return
 	}
 

polkadot/node/network/collator-protocol/src/collator_side/mod.rs

@@ -777,7 +777,7 @@ async fn send_collation(
 	};
 
 	if let Err(_) = request.send_outgoing_response(response) {
-		tracing::warn!(target: LOG_TARGET, "Sending collation response failed",);
+		tracing::warn!(target: LOG_TARGET, "Sending collation response failed");
 	}
 
 	state.active_collation_fetches.push(
@@ -913,7 +913,7 @@ where
 		PeerConnected(peer_id, observed_role, maybe_authority) => {
 			// If it is possible that a disconnected validator would attempt a reconnect
 			// it should be handled here.
-			tracing::trace!(target: LOG_TARGET, ?peer_id, ?observed_role, "Peer connected",);
+			tracing::trace!(target: LOG_TARGET, ?peer_id, ?observed_role, "Peer connected");
 			if let Some(authority) = maybe_authority {
 				tracing::trace!(
 					target: LOG_TARGET,
@@ -927,16 +927,16 @@ where
 			}
 		},
 		PeerViewChange(peer_id, view) => {
-			tracing::trace!(target: LOG_TARGET, ?peer_id, ?view, "Peer view change",);
+			tracing::trace!(target: LOG_TARGET, ?peer_id, ?view, "Peer view change");
 			handle_peer_view_change(ctx, state, peer_id, view).await;
 		},
 		PeerDisconnected(peer_id) => {
-			tracing::trace!(target: LOG_TARGET, ?peer_id, "Peer disconnected",);
+			tracing::trace!(target: LOG_TARGET, ?peer_id, "Peer disconnected");
 			state.peer_views.remove(&peer_id);
 			state.peer_ids.remove(&peer_id);
 		},
 		OurViewChange(view) => {
-			tracing::trace!(target: LOG_TARGET, ?view, "Own view change",);
+			tracing::trace!(target: LOG_TARGET, ?view, "Own view change");
 			handle_our_view_change(state, view).await?;
 		},
 		PeerMessage(remote, msg) => {

polkadot/node/network/collator-protocol/src/validator_side/mod.rs

@@ -395,7 +395,7 @@ impl ActiveParas {
 						)
 					},
 					None => {
-						tracing::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator",);
+						tracing::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator");
 
 						continue
 					},

polkadot/node/network/statement-distribution/src/lib.rs

@@ -1450,7 +1450,7 @@ async fn handle_network_update(
 ) {
 	match update {
 		NetworkBridgeEvent::PeerConnected(peer, role, maybe_authority) => {
-			tracing::trace!(target: LOG_TARGET, ?peer, ?role, "Peer connected",);
+			tracing::trace!(target: LOG_TARGET, ?peer, ?role, "Peer connected");
 			peers.insert(
 				peer,
 				PeerData {
@@ -1464,7 +1464,7 @@ async fn handle_network_update(
 			}
 		},
 		NetworkBridgeEvent::PeerDisconnected(peer) => {
-			tracing::trace!(target: LOG_TARGET, ?peer, "Peer disconnected",);
+			tracing::trace!(target: LOG_TARGET, ?peer, "Peer disconnected");
 			if let Some(auth_id) = peers.remove(&peer).and_then(|p| p.maybe_authority) {
 				authorities.remove(&auth_id);
 			}
@@ -1502,7 +1502,7 @@ async fn handle_network_update(
 			.await;
 		},
 		NetworkBridgeEvent::PeerViewChange(peer, view) => {
-			tracing::trace!(target: LOG_TARGET, ?peer, ?view, "Peer view change",);
+			tracing::trace!(target: LOG_TARGET, ?peer, ?view, "Peer view change");
 			match peers.get_mut(&peer) {
 				Some(data) =>
 					update_peer_view_and_maybe_send_unlocked(

polkadot/node/network/statement-distribution/src/tests.rs

@@ -641,7 +641,7 @@ fn circulated_statement_goes_to_all_peers_with_view() {
 			.get(&hash_b)
 			.unwrap()
 			.sent_statements
-			.contains(&fingerprint),);
+			.contains(&fingerprint));
 
 		assert!(peer_data
 			.get(&peer_c)
@@ -650,7 +650,7 @@ fn circulated_statement_goes_to_all_peers_with_view() {
 			.get(&hash_b)
 			.unwrap()
 			.sent_statements
-			.contains(&fingerprint),);
+			.contains(&fingerprint));
 
 		let message = handle.recv().await;
 		assert_matches!(

polkadot/node/subsystem-util/src/determine_new_blocks.rs

@@ -294,7 +294,7 @@ mod tests {
 			.await
 			.unwrap();
 
-			assert_eq!(ancestry, expected_ancestry,);
+			assert_eq!(ancestry, expected_ancestry);
 		});
 
 		let aux_fut = Box::pin(async move {
@@ -367,7 +367,7 @@ mod tests {
 			.await
 			.unwrap();
 
-			assert_eq!(ancestry, expected_ancestry,);
+			assert_eq!(ancestry, expected_ancestry);
 		});
 
 		let aux_fut = Box::pin(async move {
@@ -426,7 +426,7 @@ mod tests {
 			.await
 			.unwrap();
 
-			assert_eq!(ancestry, expected_ancestry,);
+			assert_eq!(ancestry, expected_ancestry);
 		});
 
 		futures::executor::block_on(test_fut);
@@ -462,7 +462,7 @@ mod tests {
 			.await
 			.unwrap();
 
-			assert_eq!(ancestry, expected_ancestry,);
+			assert_eq!(ancestry, expected_ancestry);
 		});
 
 		futures::executor::block_on(test_fut);
@@ -498,11 +498,11 @@ mod tests {
 					.await
 					.unwrap();
 
-			assert_eq!(after_finality, vec![(head_hash, head.clone())],);
+			assert_eq!(after_finality, vec![(head_hash, head.clone())]);
 
-			assert_eq!(at_finality, Vec::new(),);
+			assert_eq!(at_finality, Vec::new());
 
-			assert_eq!(before_finality, Vec::new(),);
+			assert_eq!(before_finality, Vec::new());
 		});
 
 		futures::executor::block_on(test_fut);

polkadot/node/subsystem-util/src/rolling_session_window.rs

@@ -564,7 +564,7 @@ mod tests {
 				window.cache_session_info_for_head(&mut ctx, hash, &header).await.unwrap();
 
 				assert_eq!(window.earliest_session, Some(session));
-				assert_eq!(window.session_info, vec![dummy_session_info(session)],);
+				assert_eq!(window.session_info, vec![dummy_session_info(session)]);
 			})
 		};
 

polkadot/node/test/service/tests/call-function.rs

@@ -34,7 +34,7 @@ async fn call_function_actually_work(task_executor: TaskExecutor) {
 	assert!(object.contains_key("jsonrpc"), "key jsonrpc exists");
 	let result = object.get("result");
 	let result = result.expect("key result exists");
-	assert_eq!(result.as_str().map(|x| x.starts_with("0x")), Some(true), "result starts with 0x",);
+	assert_eq!(result.as_str().map(|x| x.starts_with("0x")), Some(true), "result starts with 0x");
 
 	alice.task_manager.clean_shutdown().await;
 }