Stricter Linting with Rust 1.81+ and Clippy (#2346)

# Goal
The goal of this PR is to update and enable a bunch of Clippy lints. 

Closes #1855

# Discussion

- Most of these things are normal clippy fixes
- Highlighted the ones that are strange
- Added `make lint-fix` that runs clippy fix

# Checklist
- [x] Spec version incremented?

Author: wilwade

.maintain/frame-weight-template.hbs

@@ -134,7 +134,7 @@ mod tests {
   		frame_system::limits::BlockWeights::builder()
   			.base_block(Weight::zero())
   			.for_class(DispatchClass::all(), |weights| {
-  				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+  				weights.base_extrinsic = ExtrinsicBaseWeight::get();
   			})
   			.for_class(DispatchClass::non_mandatory(), |weights| {
   				weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
@@ -159,4 +159,4 @@ mod tests {
 	}
 	{{/if}}
 	{{/each}}
-}
+}

.maintain/runtime-weight-template.hbs

@@ -73,13 +73,14 @@ mod tests {
   use crate::constants::{MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO};
   use crate::weights::extrinsic_weights::ExtrinsicBaseWeight;
 
+  #[allow(dead_code)]
   struct BlockWeights;
   impl Get<frame_system::limits::BlockWeights> for BlockWeights {
   	fn get() -> frame_system::limits::BlockWeights {
   		frame_system::limits::BlockWeights::builder()
   			.base_block(Weight::zero())
   			.for_class(DispatchClass::all(), |weights| {
-  				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+  				weights.base_extrinsic = ExtrinsicBaseWeight::get();
   			})
   			.for_class(DispatchClass::non_mandatory(), |weights| {
   				weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
@@ -104,4 +105,4 @@ mod tests {
 	}
 	{{/if}}
 	{{/each}}
-}
+}

Cargo.toml

@@ -172,42 +172,6 @@ sp-debug-derive = { git = "https://github.com/paritytech/polkadot-sdk", branch =
 nonstandard-style = "deny"
 
 [workspace.lints.clippy]
-# These should all be removed and lints fixed/ignored in the next PR
-collapsible_else_if = "allow"
-collapsible_if = "allow"
-single_component_path_imports = "allow"
-doc_lazy_continuation = "allow"
-manual_unwrap_or_default = "allow"
-duplicated_attributes = "allow"
-expect_used = "allow"
-into_iter_on_ref = "allow"
-legacy_numeric_constants = "allow"
-unwrap_or_default = "allow"
-single_match = "allow"
-manual_range_contains = "allow"
-iter_cloned_collect = "allow"
-enum_variant_names = "allow"
-let_and_return = "allow"
-let_unit_value = "allow"
-match_ref_pats = "allow"
-multiple_bound_locations = "allow"
-needless_borrow = "allow"
-needless_borrows_for_generic_args = "allow"
-needless_return = "allow"
-ptr_arg = "allow"
-tabs_in_doc_comments = "allow"
-empty_line_after_doc_comments = "allow"
-redundant_closure = "allow"
-redundant_static_lifetimes = "allow"
-unconditional_recursion = "allow"
-unnecessary_cast = "allow"
-unwrap_used = "allow"
-useless_conversion = "allow"
-useless_vec = "allow"
-while_let_on_iterator = "allow"
-match_like_matches_macro = "allow"
-nonminimal_bool = "allow"
-non_minimal_cfg = "allow"
 # We just deny everything so that we can then build up from there
 correctness = { level = "deny", priority = -1 }
 style = { level = "deny", priority = -1 }
@@ -227,6 +191,7 @@ get_first = "allow"
 len_zero = "allow"
 large_enum_variant = "allow"
 empty_line_after_outer_attr = "allow"
+enum_variant_names = "allow"
 
 [profile.release]
 panic = "unwind"

README.md

@@ -59,7 +59,7 @@ Frequency is a [Polkadot](https://www.parity.io/technologies/polkadot) parachain
 
 ## Hardware
 
-Benchmarks are run on an AWS `c6i.4xlarge` and recommend collators have generally the same [reference hardware specified by Parity for Validators](https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware).
+Benchmarks are run on an AWS `m6id.2xlarge` and recommend collators have generally the same [reference hardware specified by Parity for Validators](https://docs.polkadot.com/infrastructure/running-a-validator/requirements/#minimum-hardware-requirements).
 
 Non-Collator nodes may have less power, but low memory configurations may lead to out of memory errors.
 

common/helpers/src/avro.rs

@@ -190,13 +190,13 @@ pub fn get_schema_data_map<'a>(
 /// let schema_fingerprint = avro::fingerprint_raw_schema(raw_schema);
 /// assert!(schema_fingerprint.is_ok());
 /// ```
-pub fn validate_raw_avro_schema(json_schema: &Vec<u8>) -> Result<(), AvroError> {
-	match String::from_utf8(json_schema.clone()) {
+pub fn validate_raw_avro_schema(json_schema: &[u8]) -> Result<(), AvroError> {
+	match String::from_utf8(json_schema.to_owned()) {
 		Err(_e) => Err(AvroError::InvalidSchema("Invalid schema".to_string())),
 		Ok(avro_schema) => {
 			let schema_fingerprint = fingerprint_raw_schema(&avro_schema);
 			if schema_fingerprint.is_err() {
-				return Err(AvroError::InvalidSchema("Invalid schema".to_string()))
+				return Err(AvroError::InvalidSchema("Invalid schema".to_string()));
 			}
 			Ok(())
 		},

common/helpers/src/avro_tests.rs

@@ -397,9 +397,7 @@ fn test_bad_records() {
 	let translated_schema = translate_schema.unwrap();
 	let writer = avro::get_schema_data_writer(&translated_schema);
 	assert_eq!(writer.schema(), &translated_schema);
-	let mut serialized_result = Vec::new();
-	// populated serialized_result
-	serialized_result.push(0x0);
+	let serialized_result = vec![0u8];
 	let reader_res = avro::get_schema_data_map(&serialized_result, &translated_schema);
 	assert!(reader_res.is_err());
 }

common/primitives/src/messages.rs

@@ -187,7 +187,7 @@ mod tests {
 			"{\"provider_msa_id\":1,\"index\":1,\"block_number\":1,\"msa_id\":1}";
 
 		let deserialized_result: MessageResponse =
-			serde_json::from_str(&serialized_msg_without_payload).unwrap();
+			serde_json::from_str(serialized_msg_without_payload).unwrap();
 		assert_eq!(deserialized_result, expected_msg);
 	}
 
@@ -257,9 +257,9 @@ mod tests {
 			&request,
 		);
 		// NOT FULL
-		assert_eq!(false, is_full);
+		assert!(!is_full);
 		// NOTHING MORE
-		assert_eq!(false, resp.has_next);
+		assert!(!resp.has_next);
 		// None
 		assert_eq!(None, resp.next_block);
 		assert_eq!(None, resp.next_index);
@@ -294,8 +294,8 @@ mod tests {
 			list_size,
 			&request,
 		);
-		assert_eq!(true, is_full);
-		assert_eq!(true, resp.has_next);
+		assert!(is_full);
+		assert!(resp.has_next);
 		// SAME block
 		assert_eq!(Some(1), resp.next_block);
 		// NEXT index
@@ -331,8 +331,8 @@ mod tests {
 			list_size,
 			&request,
 		);
-		assert_eq!(true, is_full);
-		assert_eq!(true, resp.has_next);
+		assert!(is_full);
+		assert!(resp.has_next);
 		// NEXT block
 		assert_eq!(Some(current_block + 1), resp.next_block);
 		// ZERO index

common/primitives/src/offchain.rs

@@ -6,7 +6,7 @@ use sp_externalities::ExternalitiesExt;
 use sp_runtime::offchain::storage::{StorageRetrievalError, StorageValueRef};
 use sp_runtime_interface::runtime_interface;
 extern crate alloc;
-use alloc::{vec, vec::Vec};
+use alloc::vec::Vec;
 use core::fmt::Debug;
 
 #[cfg(feature = "std")]
@@ -35,12 +35,12 @@ pub const MSA_ACCOUNT_STORAGE_NAME_PREFIX: &[u8; 16] = b"Msa::ofw::keys::";
 /// msa account lock name
 pub fn get_msa_account_lock_name(msa_id: MessageSourceId) -> Vec<u8> {
 	let mut buff = [0u8; 30];
-	vec![MSA_ACCOUNT_LOCK_NAME_PREFIX, msa_id.numtoa(10, &mut buff)].concat()
+	[MSA_ACCOUNT_LOCK_NAME_PREFIX, msa_id.numtoa(10, &mut buff)].concat()
 }
 /// msa account storage key name
 pub fn get_msa_account_storage_key_name(msa_id: MessageSourceId) -> Vec<u8> {
 	let mut buff = [0u8; 30];
-	vec![MSA_ACCOUNT_STORAGE_NAME_PREFIX, msa_id.numtoa(10, &mut buff)].concat()
+	[MSA_ACCOUNT_STORAGE_NAME_PREFIX, msa_id.numtoa(10, &mut buff)].concat()
 }
 
 /// Locks the execution of the function

common/primitives/src/schema.rs

@@ -138,7 +138,7 @@ pub trait SchemaProvider<SchemaId> {
 /// This allows other Pallets to check validity of schema ids.
 pub trait SchemaValidator<SchemaId> {
 	/// Checks that a collection of SchemaIds are all valid
-	fn are_all_schema_ids_valid(schema_ids: &Vec<SchemaId>) -> bool;
+	fn are_all_schema_ids_valid(schema_ids: &[SchemaId]) -> bool;
 
 	/// Set the schema counter for testing purposes.
 	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]

common/primitives/src/signatures.rs

@@ -254,7 +254,7 @@ impl Into<UnifiedSignature> for MultiSignature {
 }
 
 fn check_secp256k1_signature(signature: &[u8; 65], msg: &[u8; 32], signer: &AccountId32) -> bool {
-	match sp_io::crypto::secp256k1_ecdsa_recover(signature, &msg) {
+	match sp_io::crypto::secp256k1_ecdsa_recover(signature, msg) {
 		Ok(pubkey) => {
 			let mut hashed = sp_io::hashing::keccak_256(pubkey.as_ref());
 			hashed[..12].fill(0);
@@ -284,13 +284,13 @@ fn check_ethereum_signature<L: Lazy<[u8]>>(
 	};
 
 	// signature of ethereum prefixed message eip-191
-	let message_prefixed = eth_message_hash(&msg.get());
-	if verify_signature(&signature.as_ref(), &message_prefixed, signer) {
+	let message_prefixed = eth_message_hash(msg.get());
+	if verify_signature(signature.as_ref(), &message_prefixed, signer) {
 		return true
 	}
 
 	// signature of raw payload, compatible with polkadotJs signatures
-	let hashed = sp_io::hashing::keccak_256(&msg.get());
+	let hashed = sp_io::hashing::keccak_256(msg.get());
 	verify_signature(signature.as_ref(), &hashed, signer)
 }
 
@@ -306,10 +306,10 @@ mod tests {
 		let msg = &b"test-message"[..];
 		let (pair, _) = ecdsa::Pair::generate();
 
-		let signature = pair.sign(&msg);
+		let signature = pair.sign(msg);
 		let unified_sig = UnifiedSignature::from(signature);
 		let unified_signer = UnifiedSigner::from(pair.public());
-		assert_eq!(unified_sig.verify(msg, &unified_signer.into_account()), false);
+		assert!(!unified_sig.verify(msg, &unified_signer.into_account()));
 	}
 
 	#[test]
@@ -365,6 +365,6 @@ mod tests {
 				.expect("invalid size"),
 		);
 		let unified_signer = UnifiedSigner::from(public_key);
-		assert_eq!(unified_signature.verify(&payload[..], &unified_signer.into_account()), false);
+		assert!(!unified_signature.verify(&payload[..], &unified_signer.into_account()));
 	}
 }

common/primitives/src/utils.rs

@@ -68,13 +68,11 @@ pub mod as_hex_option {
 	}
 
 	/// Deserializes a hexadecimal string into a `Vec<u8>`
-	pub fn deserialize<'de, D: Deserializer<'de>>(
-		deserializer: D,
-	) -> Result<Option<Vec<u8>>, D::Error>
+	pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
 	where
 		D: Deserializer<'de>,
 	{
-		impl_serde::serialize::deserialize(deserializer).map(|r| Some(r))
+		impl_serde::serialize::deserialize(deserializer).map(Some)
 	}
 }
 /// Handle serializing and deserializing from `Vec<u8>` to a UTF-8 string
@@ -84,7 +82,7 @@ pub mod as_string {
 	use serde::{ser::Error, Deserialize, Deserializer, Serialize, Serializer};
 
 	/// Serializes a `Vec<u8>` into a UTF-8 string
-	pub fn serialize<S: Serializer>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error> {
+	pub fn serialize<S: Serializer>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
 		std::str::from_utf8(bytes)
 			.map_err(|e| S::Error::custom(format!("Debug buffer contains invalid UTF8: {}", e)))?
 			.serialize(serializer)
@@ -129,8 +127,8 @@ pub mod as_string_option {
 	}
 }
 
-const PREFIX: &'static str = "<Bytes>";
-const POSTFIX: &'static str = "</Bytes>";
+const PREFIX: &str = "<Bytes>";
+const POSTFIX: &str = "</Bytes>";
 
 /// Wraps `PREFIX` and `POSTFIX` around a `Vec<u8>`
 /// Returns `PREFIX` ++ `data` ++ `POSTFIX`

node/cli/src/benchmarking.rs

@@ -14,11 +14,9 @@ use sp_keyring::Sr25519Keyring;
 use sp_runtime::{OpaqueExtrinsic, SaturatedConversion};
 
 use pallet_balances::Call as BalancesCall;
-use pallet_msa;
 use sp_inherents::InherentDataProvider;
 #[allow(deprecated)]
 use sp_runtime::traits::transaction_extension::AsTransactionExtension;
-use sp_timestamp;
 use std::{sync::Arc, time::Duration};
 
 /// Generates extrinsics for the `benchmark overhead` command.
@@ -88,11 +86,8 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
 		let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
 			self.client.as_ref(),
 			acc,
-			BalancesCall::transfer_keep_alive {
-				dest: self.dest.clone().into(),
-				value: self.value.into(),
-			}
-			.into(),
+			BalancesCall::transfer_keep_alive { dest: self.dest.clone().into(), value: self.value }
+				.into(),
 			nonce,
 		)
 		.into();

node/cli/src/command.rs

@@ -47,6 +47,7 @@ impl IdentifyChain for dyn sc_service::ChainSpec {
 
 impl PartialEq for ChainIdentity {
 	fn eq(&self, other: &Self) -> bool {
+		#[allow(clippy::match_like_matches_macro)]
 		match (self, other) {
 			(ChainIdentity::Frequency, ChainIdentity::Frequency) => true,
 			(ChainIdentity::FrequencyPaseo, ChainIdentity::FrequencyPaseo) => true,
@@ -66,18 +67,17 @@ impl<T: sc_service::ChainSpec + 'static> IdentifyChain for T {
 fn load_spec(id: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
 	match id {
 		#[cfg(feature = "runtime-benchmarks")]
-		"frequency-bench" => return Ok(Box::new(chain_spec::frequency::benchmark_mainnet_config())),
+		"frequency-bench" => Ok(Box::new(chain_spec::frequency::benchmark_mainnet_config())),
 		#[cfg(feature = "frequency")]
-		"frequency" => return Ok(Box::new(chain_spec::frequency::load_frequency_spec())),
+		"frequency" => Ok(Box::new(chain_spec::frequency::load_frequency_spec())),
 		#[cfg(feature = "frequency-no-relay")]
-		"dev" | "frequency-no-relay" =>
-			return Ok(Box::new(chain_spec::frequency_dev::development_config())),
+		"dev" | "frequency-no-relay" => Ok(Box::new(chain_spec::frequency_dev::development_config())),
 		#[cfg(feature = "frequency-local")]
 		"frequency-paseo-local" =>
-			return Ok(Box::new(chain_spec::frequency_paseo::local_paseo_testnet_config())),
+			Ok(Box::new(chain_spec::frequency_paseo::local_paseo_testnet_config())),
 		#[cfg(feature = "frequency-testnet")]
 		"frequency-testnet" | "frequency-paseo" | "paseo" | "testnet" =>
-			return Ok(Box::new(chain_spec::frequency_paseo::load_frequency_paseo_spec())),
+			Ok(Box::new(chain_spec::frequency_paseo::load_frequency_paseo_spec())),
 		path => {
 			if path.is_empty() {
 				if cfg!(feature = "frequency") {
@@ -122,9 +122,7 @@ fn load_spec(id: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
 			if ChainIdentity::Frequency == spec.identify() {
 				#[cfg(feature = "frequency")]
 				{
-					return Ok(Box::new(chain_spec::frequency::ChainSpec::from_json_file(
-						path_buf,
-					)?));
+					Ok(Box::new(chain_spec::frequency::ChainSpec::from_json_file(path_buf)?))
 				}
 				#[cfg(not(feature = "frequency"))]
 				return Err("Frequency runtime is not available.".into());
@@ -240,13 +238,12 @@ impl SubstrateCli for RelayChainCli {
 		match id {
 			// TODO: Remove once on a Polkadot-SDK with Paseo-Local
 			#[cfg(feature = "frequency-local")]
-			"paseo-local" => return Ok(Box::new(chain_spec::frequency_paseo::load_paseo_local_spec())),
+			"paseo-local" => Ok(Box::new(chain_spec::frequency_paseo::load_paseo_local_spec())),
 			// TODO: Remove once on a Polkadot-SDK with Paseo
 			#[cfg(feature = "frequency-testnet")]
-			"paseo" => return Ok(Box::new(chain_spec::frequency_paseo::load_paseo_spec())),
-			_ =>
-				return polkadot_cli::Cli::from_iter([RelayChainCli::executable_name()].iter())
-					.load_spec(id),
+			"paseo" => Ok(Box::new(chain_spec::frequency_paseo::load_paseo_spec())),
+			_ => polkadot_cli::Cli::from_iter([RelayChainCli::executable_name()].iter())
+				.load_spec(id),
 		}
 	}
 }
@@ -346,9 +343,9 @@ pub fn run() -> Result<()> {
 							))
 						})
 					} else {
-						return Err("Benchmarking wasn't enabled when building the node. \
+						Err("Benchmarking wasn't enabled when building the node. \
 									You can enable it with `--features runtime-benchmarks`."
-							.into());
+							.into())
 					},
 				BenchmarkCmd::Block(cmd) => runner.sync_run(|config| {
 					let partials = new_partial(&config, false)?;

node/cli/src/run_as_parachain.rs

@@ -37,7 +37,7 @@ pub fn run_as_parachain(cli: Cli) -> sc_service::Result<(), sc_cli::Error> {
 		info!("Parachain id: {:?}", id);
 		info!("Is collating: {}", if config.role.is_authority() { "yes" } else { "no" });
 
-		return frequency_service::service::start_parachain_node(
+		frequency_service::service::start_parachain_node(
 			config,
 			polkadot_config,
 			collator_options,