Enforce match_arm_blocks = true for consistent formatting

.rustfmt.toml

@@ -16,7 +16,7 @@ spaces_around_ranges = false
 binop_separator = "Back"
 reorder_impl_items = false
 match_arm_leading_pipes = "Never"
-match_arm_blocks = false
+match_arm_blocks = true
 match_block_trailing_comma = true
 trailing_comma = "Vertical"
 trailing_semicolon = true

bridges/modules/grandpa/src/call_ext.rs

@@ -248,8 +248,9 @@ pub trait CallSubType<T: Config<I, RuntimeCall = Self>, I: 'static>:
 
 		let result = SubmitFinalityProofHelper::<T, I>::check_obsolete_from_extension(&call_info);
 		match result {
-			Ok(improved_by) =>
-				Ok(Some(VerifiedSubmitFinalityProofInfo { base: call_info, improved_by })),
+			Ok(improved_by) => {
+				Ok(Some(VerifiedSubmitFinalityProofInfo { base: call_info, improved_by }))
+			},
 			Err(Error::<T, I>::OldHeader) => Err(InvalidTransaction::Stale.into()),
 			Err(_) => Err(InvalidTransaction::Call.into()),
 		}

bridges/modules/messages/src/tests/messages_generation.rs

@@ -78,12 +78,13 @@ where
 		for (i, nonce) in message_nonces.into_iter().enumerate() {
 			let message_key = MessageKey { lane_id: lane, nonce };
 			let message_payload = match encode_message(nonce, &generate_message(nonce)) {
-				Some(message_payload) =>
+				Some(message_payload) => {
 					if i == 0 {
 						grow_storage_value(message_payload, &proof_params)
 					} else {
 						message_payload
-					},
+					}
+				},
 				None => continue,
 			};
 			let storage_key = storage_keys::message_key(

bridges/modules/parachains/src/call_ext.rs

@@ -158,12 +158,13 @@ impl<T: Config<I>, I: 'static> SubmitParachainHeadsHelper<T, I> {
 	/// Check if the `SubmitParachainHeads` was successfully executed.
 	pub fn was_successful(update: &SubmitParachainHeadsInfo) -> bool {
 		match crate::ParasInfo::<T, I>::get(update.para_id) {
-			Some(stored_best_head) =>
+			Some(stored_best_head) => {
 				stored_best_head.best_head_hash ==
 					BestParaHeadHash {
 						at_relay_block_number: update.at_relay_block.0,
 						head_hash: update.para_head_hash,
-					},
+					}
+			},
 			None => false,
 		}
 	}

bridges/modules/parachains/src/lib.rs

@@ -530,7 +530,9 @@ pub mod pallet {
 									if at_relay_block.0.saturating_sub(
 										best_head.best_head_hash.at_relay_block_number,
 									) >= free_headers_interval =>
-									true,
+								{
+									true
+								},
 								Some(_) => false,
 								None => true,
 							};

bridges/modules/relayers/src/extension/grandpa_adapter.rs

@@ -109,8 +109,9 @@ where
 			calls.next().transpose()?.and_then(|c| c.submit_finality_proof_info());
 
 		Ok(match (total_calls, relay_finality_call, msgs_call) {
-			(2, Some(relay_finality_call), Some(msgs_call)) =>
-				Some(ExtensionCallInfo::RelayFinalityAndMsgs(relay_finality_call, msgs_call)),
+			(2, Some(relay_finality_call), Some(msgs_call)) => {
+				Some(ExtensionCallInfo::RelayFinalityAndMsgs(relay_finality_call, msgs_call))
+			},
 			(1, None, Some(msgs_call)) => Some(ExtensionCallInfo::Msgs(msgs_call)),
 			_ => None,
 		})

bridges/modules/relayers/src/extension/mod.rs

@@ -407,11 +407,12 @@ where
 					"Has registered reward"
 				);
 			},
-			RelayerAccountAction::Slash(relayer, slash_account) =>
+			RelayerAccountAction::Slash(relayer, slash_account) => {
 				RelayersPallet::<R, C::BridgeRelayersPalletInstance>::slash_and_deregister(
 					&relayer,
 					ExplicitOrAccountParams::Params(slash_account),
-				),
+				)
+			},
 		}
 
 		Ok(Weight::zero())

bridges/modules/relayers/src/extension/parachain_adapter.rs

@@ -122,14 +122,16 @@ where
 		let relay_finality_call =
 			calls.next().transpose()?.and_then(|c| c.submit_finality_proof_info());
 		Ok(match (total_calls, relay_finality_call, para_finality_call, msgs_call) {
-			(3, Some(relay_finality_call), Some(para_finality_call), Some(msgs_call)) =>
+			(3, Some(relay_finality_call), Some(para_finality_call), Some(msgs_call)) => {
 				Some(ExtensionCallInfo::AllFinalityAndMsgs(
 					relay_finality_call,
 					para_finality_call,
 					msgs_call,
-				)),
-			(2, None, Some(para_finality_call), Some(msgs_call)) =>
-				Some(ExtensionCallInfo::ParachainFinalityAndMsgs(para_finality_call, msgs_call)),
+				))
+			},
+			(2, None, Some(para_finality_call), Some(msgs_call)) => {
+				Some(ExtensionCallInfo::ParachainFinalityAndMsgs(para_finality_call, msgs_call))
+			},
 			(1, None, None, Some(msgs_call)) => Some(ExtensionCallInfo::Msgs(msgs_call)),
 			_ => None,
 		})

bridges/modules/xcm-bridge-hub-router/src/lib.rs

@@ -279,7 +279,9 @@ impl<T: Config<I>, I: 'static> ExporterFor for Pallet<T, I> {
 			match T::Bridges::exporter_for(network, remote_location, message) {
 				Some((bridge_hub_location, maybe_payment))
 					if bridge_hub_location.eq(&T::SiblingBridgeHubLocation::get()) =>
-					(bridge_hub_location, maybe_payment),
+				{
+					(bridge_hub_location, maybe_payment)
+				},
 				_ => {
 					tracing::trace!(
 						target: LOG_TARGET,

bridges/modules/xcm-bridge-hub/src/exporter.rs

@@ -159,12 +159,15 @@ where
 		let bridge_message = MessagesPallet::<T, I>::validate_message(bridge.lane_id, &blob)
 			.map_err(|e| {
 				match e {
-					Error::LanesManager(ref ei) =>
-						tracing::error!(target: LOG_TARGET, error=?ei, "LanesManager"),
-					Error::MessageRejectedByPallet(ref ei) =>
-						tracing::error!(target: LOG_TARGET, error=?ei, "MessageRejectedByPallet"),
-					Error::ReceptionConfirmation(ref ei) =>
-						tracing::error!(target: LOG_TARGET, error=?ei, "ReceptionConfirmation"),
+					Error::LanesManager(ref ei) => {
+						tracing::error!(target: LOG_TARGET, error=?ei, "LanesManager")
+					},
+					Error::MessageRejectedByPallet(ref ei) => {
+						tracing::error!(target: LOG_TARGET, error=?ei, "MessageRejectedByPallet")
+					},
+					Error::ReceptionConfirmation(ref ei) => {
+						tracing::error!(target: LOG_TARGET, error=?ei, "ReceptionConfirmation")
+					},
 					_ => (),
 				};
 

bridges/modules/xcm-bridge-hub/src/lib.rs

@@ -758,8 +758,9 @@ pub mod pallet {
 
 				let lane_id = match maybe_lane_id {
 					Some(lane_id) => *lane_id,
-					None =>
-						locations.calculate_lane_id(xcm::latest::VERSION).expect("Valid locations"),
+					None => {
+						locations.calculate_lane_id(xcm::latest::VERSION).expect("Valid locations")
+					},
 				};
 
 				Pallet::<T, I>::do_open_bridge(locations, lane_id, true)

bridges/primitives/messages/src/lib.rs

@@ -291,8 +291,9 @@ impl<RelayerId> InboundLaneData<RelayerId> {
 	pub fn total_unrewarded_messages(&self) -> MessageNonce {
 		let relayers = &self.relayers;
 		match (relayers.front(), relayers.back()) {
-			(Some(front), Some(back)) =>
-				(front.messages.begin..=back.messages.end).saturating_len(),
+			(Some(front), Some(back)) => {
+				(front.messages.begin..=back.messages.end).saturating_len()
+			},
 			_ => 0,
 		}
 	}

bridges/primitives/relayers/src/extension.rs

@@ -181,7 +181,9 @@ where
 		match call.is_sub_type() {
 			Some(UtilityCall::<Runtime>::batch_all { ref calls })
 				if calls.len() <= max_packed_calls as usize =>
-				calls.iter().collect(),
+			{
+				calls.iter().collect()
+			},
 			Some(_) => vec![],
 			None => vec![call],
 		}

bridges/primitives/relayers/src/registration.rs

@@ -71,8 +71,9 @@ impl<AccountId: Decode + Encode, LaneId: Decode + Encode> IdentifyAccount
 	fn into_account(self) -> Self::AccountId {
 		match self {
 			ExplicitOrAccountParams::Explicit(account_id) => account_id,
-			ExplicitOrAccountParams::Params(params) =>
-				PayRewardFromAccount::<(), AccountId, LaneId, ()>::rewards_account(params),
+			ExplicitOrAccountParams::Params(params) => {
+				PayRewardFromAccount::<(), AccountId, LaneId, ()>::rewards_account(params)
+			},
 		}
 	}
 }

bridges/primitives/runtime/src/chain.rs

@@ -44,17 +44,19 @@ impl<ChainCall: Clone + Codec> EncodedOrDecodedCall<ChainCall> {
 	/// Returns decoded call.
 	pub fn to_decoded(&self) -> Result<ChainCall, codec::Error> {
 		match self {
-			Self::Encoded(ref encoded_call) =>
-				ChainCall::decode(&mut &encoded_call[..]).map_err(Into::into),
+			Self::Encoded(ref encoded_call) => {
+				ChainCall::decode(&mut &encoded_call[..]).map_err(Into::into)
+			},
 			Self::Decoded(ref decoded_call) => Ok(decoded_call.clone()),
 		}
 	}
 
 	/// Converts self to decoded call.
 	pub fn into_decoded(self) -> Result<ChainCall, codec::Error> {
 		match self {
-			Self::Encoded(encoded_call) =>
-				ChainCall::decode(&mut &encoded_call[..]).map_err(Into::into),
+			Self::Encoded(encoded_call) => {
+				ChainCall::decode(&mut &encoded_call[..]).map_err(Into::into)
+			},
 			Self::Decoded(decoded_call) => Ok(decoded_call),
 		}
 	}

bridges/primitives/runtime/src/lib.rs

@@ -205,8 +205,9 @@ impl<BlockNumber: Copy + UniqueSaturatedInto<u64>, BlockHash: Copy>
 			TransactionEra::Immortal => sp_runtime::generic::Era::immortal(),
 			// `unique_saturated_into` is fine here - mortality `u64::MAX` is not something we
 			// expect to see on any chain
-			TransactionEra::Mortal(header_id, period) =>
-				sp_runtime::generic::Era::mortal(period as _, header_id.0.unique_saturated_into()),
+			TransactionEra::Mortal(header_id, period) => {
+				sp_runtime::generic::Era::mortal(period as _, header_id.0.unique_saturated_into())
+			},
 		}
 	}
 
@@ -396,7 +397,9 @@ pub trait OwnedBridgeModule<T: frame_system::Config> {
 			Ok(RawOrigin::Root) => Ok(()),
 			Ok(RawOrigin::Signed(ref signer))
 				if Self::OwnerStorage::get().as_ref() == Some(signer) =>
-				Ok(()),
+			{
+				Ok(())
+			},
 			_ => Err(BadOrigin),
 		}
 	}

bridges/relays/client-substrate/src/client/rpc.rs

@@ -173,8 +173,9 @@ impl<C: Chain> RpcClient<C> {
 		// same and we need to abort if actual version is > than expected
 		let actual = SimpleRuntimeVersion::from_runtime_version(&env.runtime_version().await?);
 		match actual.spec_version.cmp(&expected.spec_version) {
-			Ordering::Less =>
-				Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual }),
+			Ordering::Less => {
+				Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual })
+			},
 			Ordering::Equal => Ok(()),
 			Ordering::Greater => {
 				tracing::error!(

bridges/relays/client-substrate/src/error.rs

@@ -420,8 +420,9 @@ impl MaybeConnectionError for Error {
 	fn is_connection_error(&self) -> bool {
 		match *self {
 			Error::ChannelError(_) => true,
-			Error::RpcError(ref e) =>
-				matches!(*e, RpcError::Transport(_) | RpcError::RestartNeeded(_),),
+			Error::RpcError(ref e) => {
+				matches!(*e, RpcError::Transport(_) | RpcError::RestartNeeded(_),)
+			},
 			Error::ClientNotSynced(_) => true,
 			Error::UnorderedFinalizedHeaders { .. } => true,
 			_ => self.nested().map(|e| e.is_connection_error()).unwrap_or(false),

bridges/relays/client-substrate/src/transaction_tracker.rs

@@ -121,10 +121,12 @@ impl<C: Chain, E: Environment<C>> TransactionTracker<C, E> {
 				(TrackedTransactionStatus::Lost, None)
 			},
 			Either::Right((invalidation_status, _)) => match invalidation_status {
-				InvalidationStatus::Finalized(at_block) =>
-					(TrackedTransactionStatus::Finalized(at_block), Some(invalidation_status)),
-				InvalidationStatus::Invalid =>
-					(TrackedTransactionStatus::Lost, Some(invalidation_status)),
+				InvalidationStatus::Finalized(at_block) => {
+					(TrackedTransactionStatus::Finalized(at_block), Some(invalidation_status))
+				},
+				InvalidationStatus::Invalid => {
+					(TrackedTransactionStatus::Lost, Some(invalidation_status))
+				},
 				InvalidationStatus::Lost => {
 					// wait for the rest of stall timeout - this way we'll be sure that the
 					// transaction is actually dead if it has been crafted properly

bridges/relays/equivocation/src/block_checker.rs

@@ -39,8 +39,9 @@ impl<P: EquivocationDetectionPipeline> ReadSyncedHeaders<P> {
 		target_client: &mut TC,
 	) -> Result<ReadContext<P>, Self> {
 		match target_client.synced_headers_finality_info(self.target_block_num).await {
-			Ok(synced_headers) =>
-				Ok(ReadContext { target_block_num: self.target_block_num, synced_headers }),
+			Ok(synced_headers) => {
+				Ok(ReadContext { target_block_num: self.target_block_num, synced_headers })
+			},
 			Err(e) => {
 				tracing::error!(
 					target: "bridge",
@@ -127,13 +128,14 @@ impl<P: EquivocationDetectionPipeline> FindEquivocations<P> {
 				&synced_header.finality_proof,
 				finality_proofs_buf.buf().as_slice(),
 			) {
-				Ok(equivocations) =>
+				Ok(equivocations) => {
 					if !equivocations.is_empty() {
 						result.push(ReportEquivocations {
 							source_block_hash: self.context.synced_header_hash,
 							equivocations,
 						})
-					},
+					}
+				},
 				Err(e) => {
 					tracing::error!(
 						target: "bridge",

bridges/relays/finality/src/headers.rs

@@ -128,8 +128,9 @@ impl<P: FinalitySyncPipeline> JustifiedHeaderSelector<P> {
 	) -> Option<JustifiedHeader<P>> {
 		let (unjustified_headers, maybe_justified_header) = match self {
 			JustifiedHeaderSelector::Mandatory(justified_header) => return Some(justified_header),
-			JustifiedHeaderSelector::Regular(unjustified_headers, justified_header) =>
-				(unjustified_headers, Some(justified_header)),
+			JustifiedHeaderSelector::Regular(unjustified_headers, justified_header) => {
+				(unjustified_headers, Some(justified_header))
+			},
 			JustifiedHeaderSelector::None(unjustified_headers) => (unjustified_headers, None),
 		};
 
@@ -194,14 +195,15 @@ fn need_to_relay<P: FinalitySyncPipeline>(
 	match headers_to_relay {
 		HeadersToRelay::All => true,
 		HeadersToRelay::Mandatory => header.is_mandatory(),
-		HeadersToRelay::Free =>
+		HeadersToRelay::Free => {
 			header.is_mandatory() ||
 				free_headers_interval
 					.map(|free_headers_interval| {
 						header.number().saturating_sub(info.best_number_at_target) >=
 							free_headers_interval
 					})
-					.unwrap_or(false),
+					.unwrap_or(false)
+		},
 	}
 }
 

bridges/relays/lib-substrate-relay/src/messages/mod.rs

@@ -211,13 +211,14 @@ where
 	let max_messages_size_in_single_batch = P::TargetChain::max_extrinsic_size() / 3;
 	let limits = match params.limits {
 		Some(limits) => limits,
-		None =>
+		None => {
 			select_delivery_transaction_limits_rpc(
 				&params,
 				P::TargetChain::max_extrinsic_weight(),
 				P::SourceChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
 			)
-			.await?,
+			.await?
+		},
 	};
 	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) =
 		(limits.max_messages_in_single_batch / 2, limits.max_messages_weight_in_single_batch / 2);
@@ -702,8 +703,9 @@ mod tests {
 	impl From<MockUtilityCall<RuntimeCall>> for RuntimeCall {
 		fn from(value: MockUtilityCall<RuntimeCall>) -> RuntimeCall {
 			match value {
-				MockUtilityCall::batch_all(calls) =>
-					RuntimeCall::Utility(UtilityCall::<RuntimeCall>::batch_all(calls)),
+				MockUtilityCall::batch_all(calls) => {
+					RuntimeCall::Utility(UtilityCall::<RuntimeCall>::batch_all(calls))
+				},
 			}
 		}
 	}
@@ -755,8 +757,9 @@ mod tests {
 		);
 		match relayer_call_builder_receive_messages_proof {
 			RuntimeCall::BridgeMessages(call) => match call {
-				call @ CodegenBridgeMessagesCall::receive_messages_proof { .. } =>
-					assert_eq!(pallet_receive_messages_proof.encode(), call.encode()),
+				call @ CodegenBridgeMessagesCall::receive_messages_proof { .. } => {
+					assert_eq!(pallet_receive_messages_proof.encode(), call.encode())
+				},
 				_ => panic!("Unexpected CodegenBridgeMessagesCall type"),
 			},
 			_ => panic!("Unexpected RuntimeCall type"),
@@ -805,8 +808,9 @@ mod tests {
 		);
 		match relayer_call_builder_receive_messages_delivery_proof {
 			RuntimeCall::BridgeMessages(call) => match call {
-				call @ CodegenBridgeMessagesCall::receive_messages_delivery_proof { .. } =>
-					assert_eq!(pallet_receive_messages_delivery_proof.encode(), call.encode()),
+				call @ CodegenBridgeMessagesCall::receive_messages_delivery_proof { .. } => {
+					assert_eq!(pallet_receive_messages_delivery_proof.encode(), call.encode())
+				},
 				_ => panic!("Unexpected CodegenBridgeMessagesCall type"),
 			},
 			_ => panic!("Unexpected RuntimeCall type"),