Use same fmt and clippy configs as in Polkadot (#3004)

* Copy rustfmt.toml from Polkadot master

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

* Format with new config

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

* Add Polkadot clippy config

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

* Update Cargo.lock

Looks like paritytech/polkadot#7611 did not
correctly update the lockfile. Maybe a different Rust Version?!

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

---------

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

Author: ggwpez

cumulus/.cargo/config.toml

@@ -29,4 +29,5 @@ rustflags = [
   "-Aclippy::needless_option_as_deref",  # false positives
   "-Aclippy::derivable_impls",           # false positives
   "-Aclippy::stable_sort_primitive",     # prefer stable sort
+  "-Aclippy::extra-unused-type-parameters", # stylistic
 ]

cumulus/.rustfmt.toml

@@ -11,14 +11,18 @@ reorder_imports = true
 # Consistency
 newline_style = "Unix"
 
+# Format comments
+comment_width = 100
+wrap_comments = true
+
 # Misc
-binop_separator = "Back"
 chain_width = 80
-match_arm_blocks = false
+spaces_around_ranges = false
+binop_separator = "Back"
+reorder_impl_items = false
 match_arm_leading_pipes = "Preserve"
+match_arm_blocks = false
 match_block_trailing_comma = true
-reorder_impl_items = false
-spaces_around_ranges = false
 trailing_comma = "Vertical"
 trailing_semicolon = false
 use_field_init_shorthand = true

cumulus/client/cli/src/lib.rs

@@ -307,7 +307,8 @@ pub struct RunCmd {
 }
 
 impl RunCmd {
-	/// Create a [`NormalizedRunCmd`] which merges the `collator` cli argument into `validator` to have only one.
+	/// Create a [`NormalizedRunCmd`] which merges the `collator` cli argument into `validator` to
+	/// have only one.
 	pub fn normalize(&self) -> NormalizedRunCmd {
 		let mut new_base = self.base.clone();
 

cumulus/client/collator/src/service.rs

@@ -175,7 +175,8 @@ where
 
 	/// Fetch the collation info from the runtime.
 	///
-	/// Returns `Ok(Some(_))` on success, `Err(_)` on error or `Ok(None)` if the runtime api isn't implemented by the runtime.
+	/// Returns `Ok(Some(_))` on success, `Err(_)` on error or `Ok(None)` if the runtime api isn't
+	/// implemented by the runtime.
 	pub fn fetch_collation_info(
 		&self,
 		block_hash: Block::Hash,

cumulus/client/consensus/common/src/lib.rs

@@ -53,12 +53,14 @@ pub struct ParachainCandidate<B> {
 	pub proof: sp_trie::StorageProof,
 }
 
-/// A specific parachain consensus implementation that can be used by a collator to produce candidates.
+/// A specific parachain consensus implementation that can be used by a collator to produce
+/// candidates.
 ///
-/// The collator will call [`Self::produce_candidate`] every time there is a free core for the parachain
-/// this collator is collating for. It is the job of the consensus implementation to decide if this
-/// specific collator should build a candidate for the given relay chain block. The consensus
-/// implementation could, for example, check whether this specific collator is part of a staked set.
+/// The collator will call [`Self::produce_candidate`] every time there is a free core for the
+/// parachain this collator is collating for. It is the job of the consensus implementation to
+/// decide if this specific collator should build a candidate for the given relay chain block. The
+/// consensus implementation could, for example, check whether this specific collator is part of a
+/// staked set.
 #[async_trait::async_trait]
 pub trait ParachainConsensus<B: BlockT>: Send + Sync + dyn_clone::DynClone {
 	/// Produce a new candidate at the given parent block and relay-parent blocks.
@@ -94,8 +96,8 @@ impl<B: BlockT> ParachainConsensus<B> for Box<dyn ParachainConsensus<B> + Send +
 /// Parachain specific block import.
 ///
 /// This is used to set `block_import_params.fork_choice` to `false` as long as the block origin is
-/// not `NetworkInitialSync`. The best block for parachains is determined by the relay chain. Meaning
-/// we will update the best block, as it is included by the relay-chain.
+/// not `NetworkInitialSync`. The best block for parachains is determined by the relay chain.
+/// Meaning we will update the best block, as it is included by the relay-chain.
 pub struct ParachainBlockImport<Block: BlockT, BI, BE> {
 	inner: BI,
 	monitor: Option<SharedData<LevelMonitor<Block, BE>>>,
@@ -232,8 +234,8 @@ pub struct PotentialParent<B: BlockT> {
 /// a set of [`PotentialParent`]s which could be potential parents of a new block with this
 /// relay-parent according to the search parameters.
 ///
-/// A parachain block is a potential parent if it is either the last included parachain block, the pending
-/// parachain block (when `max_depth` >= 1), or all of the following hold:
+/// A parachain block is a potential parent if it is either the last included parachain block, the
+/// pending parachain block (when `max_depth` >= 1), or all of the following hold:
 ///   * its parent is a potential parent
 ///   * its relay-parent is within `ancestry_lookback` of the targeted relay-parent.
 ///   * the block number is within `max_depth` blocks of the included block

cumulus/client/consensus/common/src/parachain_consensus.rs

@@ -176,8 +176,8 @@ where
 ///
 /// # Note
 ///
-/// This will access the backend of the parachain and thus, this future should be spawned as blocking
-/// task.
+/// This will access the backend of the parachain and thus, this future should be spawned as
+/// blocking task.
 pub async fn run_parachain_consensus<P, R, Block, B>(
 	para_id: ParaId,
 	parachain: Arc<P>,

cumulus/client/consensus/proposer/src/lib.rs

@@ -62,8 +62,8 @@ pub trait ProposerInterface<Block: BlockT> {
 	/// `ParachainInherentData`.
 	///
 	/// Also specify any required inherent digests, the maximum proposal duration,
-	/// and the block size limit in bytes. See the documentation on [`sp_consensus::Proposer::propose`]
-	/// for more details on how to interpret these parameters.
+	/// and the block size limit in bytes. See the documentation on
+	/// [`sp_consensus::Proposer::propose`] for more details on how to interpret these parameters.
 	///
 	/// The `InherentData` and `Digest` are left deliberately general in order to accommodate
 	/// all possible collator selection algorithms or inherent creation mechanisms,

cumulus/client/consensus/relay-chain/src/lib.rs

@@ -23,7 +23,8 @@
 //!
 //! 1. Each node that sees itself as a collator is free to build a parachain candidate.
 //!
-//! 2. This parachain candidate is send to the parachain validators that are part of the relay chain.
+//! 2. This parachain candidate is send to the parachain validators that are part of the relay
+//! chain.
 //!
 //! 3. The parachain validators validate at most X different parachain candidates, where X is the
 //! total number of parachain validators.

cumulus/client/network/src/lib.rs

@@ -87,7 +87,8 @@ impl Decode for BlockAnnounceData {
 impl BlockAnnounceData {
 	/// Validate that the receipt, statement and announced header match.
 	///
-	/// This will not check the signature, for this you should use [`BlockAnnounceData::check_signature`].
+	/// This will not check the signature, for this you should use
+	/// [`BlockAnnounceData::check_signature`].
 	fn validate(&self, encoded_header: Vec<u8>) -> Result<(), Validation> {
 		let candidate_hash =
 			if let CompactStatement::Seconded(h) = self.statement.unchecked_payload() {
@@ -192,9 +193,9 @@ pub type BlockAnnounceValidator<Block, RCInterface> =
 
 /// Parachain specific block announce validator.
 ///
-/// This is not required when the collation mechanism itself is sybil-resistant, as it is a spam protection
-/// mechanism used to prevent nodes from dealing with unbounded numbers of blocks. For sybil-resistant
-/// collation mechanisms, this will only slow things down.
+/// This is not required when the collation mechanism itself is sybil-resistant, as it is a spam
+/// protection mechanism used to prevent nodes from dealing with unbounded numbers of blocks. For
+/// sybil-resistant collation mechanisms, this will only slow things down.
 ///
 /// This block announce validator is required if the parachain is running
 /// with the relay chain provided consensus to make sure each node only
@@ -472,8 +473,8 @@ impl AssumeSybilResistance {
 	/// announcements which come tagged with seconded messages.
 	///
 	/// This is useful for backwards compatibility when upgrading nodes: old nodes will continue
-	/// to broadcast announcements with seconded messages, so these announcements shouldn't be rejected
-	/// and the peers not punished.
+	/// to broadcast announcements with seconded messages, so these announcements shouldn't be
+	/// rejected and the peers not punished.
 	pub fn allow_seconded_messages() -> Self {
 		AssumeSybilResistance(true)
 	}

cumulus/client/pov-recovery/src/lib.rs

@@ -19,18 +19,19 @@
 //! A parachain needs to build PoVs that are send to the relay chain to progress. These PoVs are
 //! erasure encoded and one piece of it is stored by each relay chain validator. As the relay chain
 //! decides on which PoV per parachain to include and thus, to progess the parachain it can happen
-//! that the block corresponding to this PoV isn't propagated in the parachain network. This can have
-//! several reasons, either a malicious collator that managed to include its own PoV and doesn't want
-//! to share it with the rest of the network or maybe a collator went down before it could distribute
-//! the block in the network. When something like this happens we can use the PoV recovery algorithm
-//! implemented in this crate to recover a PoV and to propagate it with the rest of the network.
+//! that the block corresponding to this PoV isn't propagated in the parachain network. This can
+//! have several reasons, either a malicious collator that managed to include its own PoV and
+//! doesn't want to share it with the rest of the network or maybe a collator went down before it
+//! could distribute the block in the network. When something like this happens we can use the PoV
+//! recovery algorithm implemented in this crate to recover a PoV and to propagate it with the rest
+//! of the network.
 //!
 //! It works in the following way:
 //!
 //! 1. For every included relay chain block we note the backed candidate of our parachain. If the
 //!    block belonging to the PoV is already known, we do nothing. Otherwise we start
-//!    a timer that waits for a randomized time inside a specified interval before starting to recover
-//!    the PoV.
+//!    a timer that waits for a randomized time inside a specified interval before starting to
+//! recover    the PoV.
 //!
 //! 2. If between starting and firing the timer the block is imported, we skip the recovery of the
 //!    PoV.
@@ -39,8 +40,8 @@
 //!
 //! 4a. After it is recovered, we restore the block and import it.
 //!
-//! 4b. Since we are trying to recover pending candidates, availability is not guaranteed. If the block
-//!     PoV is not yet available, we retry.
+//! 4b. Since we are trying to recover pending candidates, availability is not guaranteed. If the
+//! block     PoV is not yet available, we retry.
 //!
 //! If we need to recover multiple PoV blocks (which should hopefully not happen in real life), we
 //! make sure that the blocks are imported in the correct order.