declone and close the door (#12035)

* declone and close the door

* cargo fmt

* remove brackets

substrate/.cargo/config.toml

@@ -12,8 +12,6 @@ rustflags = [
   "-Aclippy::if-same-then-else",
   "-Aclippy::clone-double-ref",
   "-Dclippy::complexity",
-  "-Aclippy::clone_on_copy",             # Too common
-  "-Aclippy::needless_lifetimes",        # Backward compat?
   "-Aclippy::zero-prefixed-literal",     # 00_1000_000
   "-Aclippy::type_complexity",           # raison d'etre
   "-Aclippy::nonminimal-bool",           # maybe

substrate/bin/node/executor/tests/basic.rs

@@ -127,7 +127,7 @@ fn blocks() -> ((Vec<u8>, Hash), (Vec<u8>, Hash)) {
 	let block2 = construct_block(
 		&mut t,
 		2,
-		block1.1.clone(),
+		block1.1,
 		vec![
 			CheckedExtrinsic {
 				signed: None,

substrate/bin/node/executor/tests/fees.rs

@@ -73,7 +73,7 @@ fn fee_multiplier_increases_and_decreases_on_big_weight() {
 	let block2 = construct_block(
 		&mut tt,
 		2,
-		block1.1.clone(),
+		block1.1,
 		vec![
 			CheckedExtrinsic {
 				signed: None,

substrate/bin/node/runtime/src/impls.rs

@@ -197,12 +197,12 @@ mod multiplier_tests {
 	fn truth_value_update_poc_works() {
 		let fm = Multiplier::saturating_from_rational(1, 2);
 		let test_set = vec![
-			(0, fm.clone()),
-			(100, fm.clone()),
-			(1000, fm.clone()),
-			(target(), fm.clone()),
-			(max_normal() / 2, fm.clone()),
-			(max_normal(), fm.clone()),
+			(0, fm),
+			(100, fm),
+			(1000, fm),
+			(target(), fm),
+			(max_normal() / 2, fm),
+			(max_normal(), fm),
 		];
 		test_set.into_iter().for_each(|(w, fm)| {
 			run_with_system_weight(w, || {

substrate/client/api/src/in_mem.rs

@@ -173,7 +173,7 @@ impl<Block: BlockT> Blockchain<Block> {
 
 		{
 			let mut storage = self.storage.write();
-			storage.leaves.import(hash, number, header.parent_hash().clone());
+			storage.leaves.import(hash, number, *header.parent_hash());
 			storage.blocks.insert(hash, StoredBlock::new(header, body, justifications));
 
 			if let NewBlockState::Final = new_state {

substrate/client/authority-discovery/src/worker/tests.rs

@@ -48,7 +48,7 @@ pub(crate) struct TestApi {
 impl ProvideRuntimeApi<Block> for TestApi {
 	type Api = RuntimeApi;
 
-	fn runtime_api<'a>(&'a self) -> ApiRef<'a, Self::Api> {
+	fn runtime_api(&self) -> ApiRef<'_, Self::Api> {
 		RuntimeApi { authorities: self.authorities.clone() }.into()
 	}
 }
@@ -530,7 +530,7 @@ impl DhtValueFoundTester {
 	) -> Option<&HashSet<Multiaddr>> {
 		let (_dht_event_tx, dht_event_rx) = channel(1);
 		let local_test_api =
-			Arc::new(TestApi { authorities: vec![self.remote_authority_public.clone().into()] });
+			Arc::new(TestApi { authorities: vec![self.remote_authority_public.into()] });
 		let local_network: Arc<TestNetwork> = Arc::new(Default::default());
 		let local_key_store = KeyStore::new();
 
@@ -555,8 +555,7 @@ impl DhtValueFoundTester {
 		self.local_worker
 			.as_ref()
 			.map(|w| {
-				w.addr_cache
-					.get_addresses_by_authority_id(&self.remote_authority_public.clone().into())
+				w.addr_cache.get_addresses_by_authority_id(&self.remote_authority_public.into())
 			})
 			.unwrap()
 	}
@@ -569,7 +568,7 @@ fn limit_number_of_addresses_added_to_cache_per_authority() {
 	let addresses = (1..100).map(|i| tester.multiaddr_with_peer_id(i)).collect();
 	let kv_pairs = block_on(build_dht_event::<TestNetwork>(
 		addresses,
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		None,
 	));
@@ -584,7 +583,7 @@ fn strict_accept_address_with_peer_signature() {
 	let addr = tester.multiaddr_with_peer_id(1);
 	let kv_pairs = block_on(build_dht_event(
 		vec![addr.clone()],
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		Some(&TestSigner { keypair: &tester.remote_node_key }),
 	));
@@ -604,7 +603,7 @@ fn reject_address_with_rogue_peer_signature() {
 	let rogue_remote_node_key = Keypair::generate_ed25519();
 	let kv_pairs = block_on(build_dht_event(
 		vec![tester.multiaddr_with_peer_id(1)],
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		Some(&TestSigner { keypair: &rogue_remote_node_key }),
 	));
@@ -622,7 +621,7 @@ fn reject_address_with_invalid_peer_signature() {
 	let mut tester = DhtValueFoundTester::new();
 	let mut kv_pairs = block_on(build_dht_event(
 		vec![tester.multiaddr_with_peer_id(1)],
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		Some(&TestSigner { keypair: &tester.remote_node_key }),
 	));
@@ -644,7 +643,7 @@ fn reject_address_without_peer_signature() {
 	let mut tester = DhtValueFoundTester::new();
 	let kv_pairs = block_on(build_dht_event::<TestNetwork>(
 		vec![tester.multiaddr_with_peer_id(1)],
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		None,
 	));
@@ -662,7 +661,7 @@ fn do_not_cache_addresses_without_peer_id() {
 		"/ip6/2001:db8:0:0:0:0:0:2/tcp/30333".parse().unwrap();
 	let kv_pairs = block_on(build_dht_event::<TestNetwork>(
 		vec![multiaddr_with_peer_id.clone(), multiaddr_without_peer_id],
-		tester.remote_authority_public.clone().into(),
+		tester.remote_authority_public.into(),
 		&tester.remote_key_store,
 		None,
 	));

substrate/client/beefy/src/round.rs

@@ -109,7 +109,7 @@ where
 	}
 
 	pub(crate) fn should_self_vote(&self, round: &(P, NumberFor<B>)) -> bool {
-		Some(round.1.clone()) > self.best_done &&
+		Some(round.1) > self.best_done &&
 			self.rounds.get(round).map(|tracker| !tracker.has_self_vote()).unwrap_or(true)
 	}
 

substrate/client/beefy/src/tests.rs

@@ -326,7 +326,7 @@ fn add_auth_change_digest(header: &mut Header, new_auth_set: BeefyValidatorSet)
 }
 
 pub(crate) fn make_beefy_ids(keys: &[BeefyKeyring]) -> Vec<AuthorityId> {
-	keys.iter().map(|key| key.clone().public().into()).collect()
+	keys.iter().map(|&key| key.public().into()).collect()
 }
 
 pub(crate) fn create_beefy_keystore(authority: BeefyKeyring) -> SyncCryptoStorePtr {

substrate/client/beefy/src/worker.rs

@@ -1134,7 +1134,7 @@ pub(crate) mod tests {
 		let mmr_root_hash = H256::random();
 		header.digest_mut().push(DigestItem::Consensus(
 			BEEFY_ENGINE_ID,
-			ConsensusLog::<AuthorityId>::MmrRoot(mmr_root_hash.clone()).encode(),
+			ConsensusLog::<AuthorityId>::MmrRoot(mmr_root_hash).encode(),
 		));
 
 		// verify validator set is correctly extracted from digest

substrate/client/cli/src/commands/chain_info_cmd.rs

@@ -77,7 +77,7 @@ impl ChainInfoCmd {
 			state_cache_child_ratio: config.state_cache_child_ratio.map(|v| (v, 100)),
 			state_pruning: config.state_pruning.clone(),
 			source: config.database.clone(),
-			blocks_pruning: config.blocks_pruning.clone(),
+			blocks_pruning: config.blocks_pruning,
 		};
 		let backend = sc_service::new_db_backend::<B>(db_config)?;
 		let info: ChainInfo<B> = backend.blockchain().info().into();

substrate/client/consensus/aura/src/lib.rs

@@ -821,7 +821,7 @@ mod tests {
 			block_import: client,
 			env: environ,
 			keystore: keystore.into(),
-			sync_oracle: DummyOracle.clone(),
+			sync_oracle: DummyOracle,
 			justification_sync_link: (),
 			force_authoring: false,
 			backoff_authoring_blocks: Some(BackoffAuthoringOnFinalizedHeadLagging::default()),
@@ -873,7 +873,7 @@ mod tests {
 			block_import: client.clone(),
 			env: environ,
 			keystore: keystore.into(),
-			sync_oracle: DummyOracle.clone(),
+			sync_oracle: DummyOracle,
 			justification_sync_link: (),
 			force_authoring: false,
 			backoff_authoring_blocks: Option::<()>::None,

substrate/client/consensus/babe/src/authorship.rs

@@ -310,7 +310,7 @@ mod tests {
 
 		assert!(claim_slot(10.into(), &epoch, &keystore).is_none());
 
-		epoch.authorities.push((valid_public_key.clone().into(), 10));
+		epoch.authorities.push((valid_public_key.into(), 10));
 		assert_eq!(claim_slot(10.into(), &epoch, &keystore).unwrap().1, valid_public_key.into());
 	}
 }

substrate/client/consensus/babe/src/tests.rs

@@ -152,7 +152,7 @@ impl DummyProposer {
 			// that will re-check the randomness logic off-chain.
 			let digest_data = ConsensusLog::NextEpochData(NextEpochDescriptor {
 				authorities: epoch.authorities.clone(),
-				randomness: epoch.randomness.clone(),
+				randomness: epoch.randomness,
 			})
 			.encode();
 			let digest = DigestItem::Consensus(BABE_ENGINE_ID, digest_data);

substrate/client/consensus/common/src/import_queue/basic_queue.rs

@@ -535,7 +535,7 @@ mod tests {
 			_number: BlockNumber,
 			_success: bool,
 		) {
-			self.events.push(Event::JustificationImported(hash.clone()))
+			self.events.push(Event::JustificationImported(*hash))
 		}
 	}
 

substrate/client/consensus/epochs/src/lib.rs

@@ -1063,7 +1063,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"A", 1, *b"0", incremented_epoch)
@@ -1080,7 +1080,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_x_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"X", 1, *b"0", incremented_epoch)
@@ -1145,7 +1145,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"A", 1, *b"0", incremented_epoch)
@@ -1162,7 +1162,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_x_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"X", 1, *b"0", incremented_epoch)
@@ -1220,7 +1220,7 @@ mod tests {
 		let incremented_epoch = epoch_changes
 			.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
 			.unwrap()
-			.increment(next_descriptor.clone());
+			.increment(next_descriptor);
 
 		epoch_changes
 			.import(&is_descendent_of, *b"1", 1, *b"0", incremented_epoch)
@@ -1330,7 +1330,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"A", 1, *b"0", incremented_epoch)
@@ -1347,7 +1347,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&epoch_b_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"B", 201, *b"A", incremented_epoch)
@@ -1364,7 +1364,7 @@ mod tests {
 			let incremented_epoch = epoch_changes
 				.viable_epoch(&genesis_epoch_x_descriptor, &make_genesis)
 				.unwrap()
-				.increment(next_descriptor.clone());
+				.increment(next_descriptor);
 
 			epoch_changes
 				.import(&is_descendent_of, *b"C", 1, *b"0", incremented_epoch)

substrate/client/consensus/manual-seal/src/lib.rs

@@ -355,7 +355,7 @@ mod tests {
 		assert_eq!(
 			created_block,
 			CreatedBlock {
-				hash: created_block.hash.clone(),
+				hash: created_block.hash,
 				aux: ImportedAux {
 					header_only: false,
 					clear_justification_requests: false,
@@ -422,7 +422,7 @@ mod tests {
 		assert_eq!(
 			created_block,
 			CreatedBlock {
-				hash: created_block.hash.clone(),
+				hash: created_block.hash,
 				aux: ImportedAux {
 					header_only: false,
 					clear_justification_requests: false,
@@ -502,7 +502,7 @@ mod tests {
 		assert_eq!(
 			created_block,
 			CreatedBlock {
-				hash: created_block.hash.clone(),
+				hash: created_block.hash,
 				aux: ImportedAux {
 					header_only: false,
 					clear_justification_requests: false,

substrate/client/db/src/lib.rs

@@ -3390,7 +3390,7 @@ pub(crate) mod tests {
 		assert!(backend.remove_leaf_block(&best_hash).is_err());
 		assert!(backend.have_state_at(&prev_hash, 1));
 		backend.remove_leaf_block(&prev_hash).unwrap();
-		assert_eq!(None, backend.blockchain().header(BlockId::hash(prev_hash.clone())).unwrap());
+		assert_eq!(None, backend.blockchain().header(BlockId::hash(prev_hash)).unwrap());
 		assert!(!backend.have_state_at(&prev_hash, 1));
 	}
 

substrate/client/db/src/storage_cache.rs

@@ -1223,7 +1223,7 @@ mod tests {
 		let mut s = CachingState::new(
 			InMemoryBackend::<BlakeTwo256>::default(),
 			shared.clone(),
-			Some(root_parent.clone()),
+			Some(root_parent),
 		);
 
 		let key = H256::random()[..].to_vec();
@@ -1307,14 +1307,14 @@ mod tests {
 		let mut s = CachingState::new(
 			InMemoryBackend::<BlakeTwo256>::default(),
 			shared.clone(),
-			Some(root_parent.clone()),
+			Some(root_parent),
 		);
 		s.cache.sync_cache(
 			&[],
 			&[],
 			vec![(key.clone(), Some(vec![2]))],
 			vec![],
-			Some(h0.clone()),
+			Some(h0),
 			Some(0),
 			true,
 		);

substrate/client/executor/wasmtime/src/host.rs

@@ -276,12 +276,11 @@ impl<'a> Sandbox for HostContext<'a> {
 				.ok_or("Runtime doesn't have a table; sandbox is unavailable")?;
 			let table_item = table.get(&mut self.caller, dispatch_thunk_id);
 
-			table_item
+			*table_item
 				.ok_or("dispatch_thunk_id is out of bounds")?
 				.funcref()
 				.ok_or("dispatch_thunk_idx should be a funcref")?
 				.ok_or("dispatch_thunk_idx should point to actual func")?
-				.clone()
 		};
 
 		let guest_env = match sandbox::GuestEnvironment::decode(self.sandbox_store(), raw_env_def) {

substrate/client/executor/wasmtime/src/instance_wrapper.rs

@@ -107,8 +107,7 @@ impl EntryPoint {
 	) -> std::result::Result<Self, &'static str> {
 		let entrypoint = func
 			.typed::<(u32, u32), u64, _>(ctx)
-			.map_err(|_| "Invalid signature for direct entry point")?
-			.clone();
+			.map_err(|_| "Invalid signature for direct entry point")?;
 		Ok(Self { call_type: EntryPointType::Direct { entrypoint } })
 	}
 
@@ -119,8 +118,7 @@ impl EntryPoint {
 	) -> std::result::Result<Self, &'static str> {
 		let dispatcher = dispatcher
 			.typed::<(u32, u32, u32), u64, _>(ctx)
-			.map_err(|_| "Invalid signature for wrapped entry point")?
-			.clone();
+			.map_err(|_| "Invalid signature for wrapped entry point")?;
 		Ok(Self { call_type: EntryPointType::Wrapped { func, dispatcher } })
 	}
 }
@@ -214,9 +212,8 @@ impl InstanceWrapper {
 						Error::from(format!("Exported method {} is not found", method))
 					})?;
 				let func = extern_func(&export)
-					.ok_or_else(|| Error::from(format!("Export {} is not a function", method)))?
-					.clone();
-				EntryPoint::direct(func, &self.store).map_err(|_| {
+					.ok_or_else(|| Error::from(format!("Export {} is not a function", method)))?;
+				EntryPoint::direct(*func, &self.store).map_err(|_| {
 					Error::from(format!("Exported function '{}' has invalid signature.", method))
 				})?
 			},
@@ -231,10 +228,9 @@ impl InstanceWrapper {
 				let func = val
 					.funcref()
 					.ok_or(Error::TableElementIsNotAFunction(func_ref))?
-					.ok_or(Error::FunctionRefIsNull(func_ref))?
-					.clone();
+					.ok_or(Error::FunctionRefIsNull(func_ref))?;
 
-				EntryPoint::direct(func, &self.store).map_err(|_| {
+				EntryPoint::direct(*func, &self.store).map_err(|_| {
 					Error::from(format!(
 						"Function @{} in exported table has invalid signature for direct call.",
 						func_ref,
@@ -252,10 +248,9 @@ impl InstanceWrapper {
 				let dispatcher = val
 					.funcref()
 					.ok_or(Error::TableElementIsNotAFunction(dispatcher_ref))?
-					.ok_or(Error::FunctionRefIsNull(dispatcher_ref))?
-					.clone();
+					.ok_or(Error::FunctionRefIsNull(dispatcher_ref))?;
 
-				EntryPoint::wrapped(dispatcher, func, &self.store).map_err(|_| {
+				EntryPoint::wrapped(*dispatcher, func, &self.store).map_err(|_| {
 					Error::from(format!(
 						"Function @{} in exported table has invalid signature for wrapped call.",
 						dispatcher_ref,
@@ -315,9 +310,8 @@ fn get_linear_memory(instance: &Instance, ctx: impl AsContextMut) -> Result<Memo
 		.get_export(ctx, "memory")
 		.ok_or_else(|| Error::from("memory is not exported under `memory` name"))?;
 
-	let memory = extern_memory(&memory_export)
-		.ok_or_else(|| Error::from("the `memory` export should have memory type"))?
-		.clone();
+	let memory = *extern_memory(&memory_export)
+		.ok_or_else(|| Error::from("the `memory` export should have memory type"))?;
 
 	Ok(memory)
 }

substrate/client/executor/wasmtime/src/tests.rs

@@ -122,7 +122,7 @@ impl RuntimeBuilder {
 		self
 	}
 
-	fn build<'a>(&'a mut self) -> impl WasmModule + 'a {
+	fn build(&mut self) -> impl WasmModule + '_ {
 		let blob = {
 			let wasm: Vec<u8>;
 

substrate/client/finality-grandpa/src/communication/gossip.rs

@@ -1729,7 +1729,7 @@ mod tests {
 		assert!(res.unwrap().is_none());
 
 		// connect & disconnect.
-		peers.new_peer(id.clone(), ObservedRole::Authority);
+		peers.new_peer(id, ObservedRole::Authority);
 		peers.peer_disconnected(&id);
 
 		let res = peers.update_peer_state(&id, update.clone());
@@ -1753,7 +1753,7 @@ mod tests {
 		let mut peers = Peers::default();
 		let id = PeerId::random();
 
-		peers.new_peer(id.clone(), ObservedRole::Authority);
+		peers.new_peer(id, ObservedRole::Authority);
 
 		let mut check_update = move |update: NeighborPacket<_>| {
 			let view = peers.update_peer_state(&id, update.clone()).unwrap().unwrap();
@@ -1773,7 +1773,7 @@ mod tests {
 		let mut peers = Peers::default();
 
 		let id = PeerId::random();
-		peers.new_peer(id.clone(), ObservedRole::Authority);
+		peers.new_peer(id, ObservedRole::Authority);
 
 		peers
 			.update_peer_state(
@@ -1964,7 +1964,7 @@ mod tests {
 		// add the peer making the request to the validator,
 		// otherwise it is discarded
 		let mut inner = val.inner.write();
-		inner.peers.new_peer(peer.clone(), ObservedRole::Authority);
+		inner.peers.new_peer(peer, ObservedRole::Authority);
 
 		let res = inner.handle_catch_up_request(
 			&peer,
@@ -2005,7 +2005,7 @@ mod tests {
 		// add the peer making the request to the validator,
 		// otherwise it is discarded
 		let peer = PeerId::random();
-		val.inner.write().peers.new_peer(peer.clone(), ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
 
 		let send_request = |set_id, round| {
 			let mut inner = val.inner.write();
@@ -2060,7 +2060,7 @@ mod tests {
 		// add the peer making the request to the validator,
 		// otherwise it is discarded.
 		let peer = PeerId::random();
-		val.inner.write().peers.new_peer(peer.clone(), ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
 
 		let import_neighbor_message = |set_id, round| {
 			let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
@@ -2130,7 +2130,7 @@ mod tests {
 		// add the peer making the request to the validator,
 		// otherwise it is discarded.
 		let peer = PeerId::random();
-		val.inner.write().peers.new_peer(peer.clone(), ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
 
 		// importing a neighbor message from a peer in the same set in a later
 		// round should lead to a catch up request but since they're disabled
@@ -2158,11 +2158,8 @@ mod tests {
 		let peer_authority = PeerId::random();
 		let peer_full = PeerId::random();
 
-		val.inner
-			.write()
-			.peers
-			.new_peer(peer_authority.clone(), ObservedRole::Authority);
-		val.inner.write().peers.new_peer(peer_full.clone(), ObservedRole::Full);
+		val.inner.write().peers.new_peer(peer_authority, ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer_full, ObservedRole::Full);
 
 		let import_neighbor_message = |peer| {
 			let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
@@ -2211,7 +2208,7 @@ mod tests {
 		// add the peer making the requests to the validator, otherwise it is
 		// discarded.
 		let peer_full = PeerId::random();
-		val.inner.write().peers.new_peer(peer_full.clone(), ObservedRole::Full);
+		val.inner.write().peers.new_peer(peer_full, ObservedRole::Full);
 
 		let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
 			&peer_full,
@@ -2271,12 +2268,9 @@ mod tests {
 		full_nodes.resize_with(30, || PeerId::random());
 
 		for i in 0..30 {
-			val.inner
-				.write()
-				.peers
-				.new_peer(authorities[i].clone(), ObservedRole::Authority);
+			val.inner.write().peers.new_peer(authorities[i], ObservedRole::Authority);
 
-			val.inner.write().peers.new_peer(full_nodes[i].clone(), ObservedRole::Full);
+			val.inner.write().peers.new_peer(full_nodes[i], ObservedRole::Full);
 		}
 
 		let test = |rounds_elapsed, peers| {
@@ -2355,7 +2349,7 @@ mod tests {
 		// add a new light client as peer
 		let light_peer = PeerId::random();
 
-		val.inner.write().peers.new_peer(light_peer.clone(), ObservedRole::Light);
+		val.inner.write().peers.new_peer(light_peer, ObservedRole::Light);
 
 		assert!(!val.message_allowed()(
 			&light_peer,
@@ -2427,7 +2421,7 @@ mod tests {
 		// add a new peer at set id 1
 		let peer1 = PeerId::random();
 
-		val.inner.write().peers.new_peer(peer1.clone(), ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer1, ObservedRole::Authority);
 
 		val.inner
 			.write()
@@ -2440,7 +2434,7 @@ mod tests {
 
 		// peer2 will default to set id 0
 		let peer2 = PeerId::random();
-		val.inner.write().peers.new_peer(peer2.clone(), ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer2, ObservedRole::Authority);
 
 		// create a commit for round 1 of set id 1
 		// targeting a block at height 2

substrate/client/finality-grandpa/src/communication/tests.rs

@@ -177,7 +177,7 @@ impl sc_network_gossip::ValidatorContext<Block> for TestNetwork {
 	fn send_message(&mut self, who: &PeerId, data: Vec<u8>) {
 		<Self as NetworkNotification>::write_notification(
 			self,
-			who.clone(),
+			*who,
 			grandpa_protocol_name::NAME.into(),
 			data,
 		);
@@ -280,7 +280,7 @@ pub(crate) fn make_test_network() -> (impl Future<Output = Tester>, TestNetwork)
 }
 
 fn make_ids(keys: &[Ed25519Keyring]) -> AuthorityList {
-	keys.iter().map(|key| key.clone().public().into()).map(|id| (id, 1)).collect()
+	keys.iter().map(|&key| key.public().into()).map(|id| (id, 1)).collect()
 }
 
 struct NoopContext;
@@ -305,8 +305,7 @@ fn good_commit_leads_to_relay() {
 		let target_hash: Hash = [1; 32].into();
 		let target_number = 500;
 
-		let precommit =
-			finality_grandpa::Precommit { target_hash: target_hash.clone(), target_number };
+		let precommit = finality_grandpa::Precommit { target_hash, target_number };
 		let payload = sp_finality_grandpa::localized_payload(
 			round,
 			set_id,
@@ -362,19 +361,19 @@ fn good_commit_leads_to_relay() {
 			// asking for global communication will cause the test network
 			// to send us an event asking us for a stream. use it to
 			// send a message.
-			let sender_id = id.clone();
+			let sender_id = id;
 			let send_message = tester.filter_network_events(move |event| match event {
 				Event::EventStream(sender) => {
 					// Add the sending peer and send the commit
 					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
-						remote: sender_id.clone(),
+						remote: sender_id,
 						protocol: grandpa_protocol_name::NAME.into(),
 						negotiated_fallback: None,
 						role: ObservedRole::Full,
 					});
 
 					let _ = sender.unbounded_send(NetworkEvent::NotificationsReceived {
-						remote: sender_id.clone(),
+						remote: sender_id,
 						messages: vec![(
 							grandpa_protocol_name::NAME.into(),
 							commit_to_send.clone().into(),
@@ -384,7 +383,7 @@ fn good_commit_leads_to_relay() {
 					// Add a random peer which will be the recipient of this message
 					let receiver_id = PeerId::random();
 					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
-						remote: receiver_id.clone(),
+						remote: receiver_id,
 						protocol: grandpa_protocol_name::NAME.into(),
 						negotiated_fallback: None,
 						role: ObservedRole::Full,
@@ -456,8 +455,7 @@ fn bad_commit_leads_to_report() {
 		let target_hash: Hash = [1; 32].into();
 		let target_number = 500;
 
-		let precommit =
-			finality_grandpa::Precommit { target_hash: target_hash.clone(), target_number };
+		let precommit = finality_grandpa::Precommit { target_hash, target_number };
 		let payload = sp_finality_grandpa::localized_payload(
 			round,
 			set_id,
@@ -513,17 +511,17 @@ fn bad_commit_leads_to_report() {
 			// asking for global communication will cause the test network
 			// to send us an event asking us for a stream. use it to
 			// send a message.
-			let sender_id = id.clone();
+			let sender_id = id;
 			let send_message = tester.filter_network_events(move |event| match event {
 				Event::EventStream(sender) => {
 					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
-						remote: sender_id.clone(),
+						remote: sender_id,
 						protocol: grandpa_protocol_name::NAME.into(),
 						negotiated_fallback: None,
 						role: ObservedRole::Full,
 					});
 					let _ = sender.unbounded_send(NetworkEvent::NotificationsReceived {
-						remote: sender_id.clone(),
+						remote: sender_id,
 						messages: vec![(
 							grandpa_protocol_name::NAME.into(),
 							commit_to_send.clone().into(),

substrate/client/finality-grandpa/src/justification.rs

@@ -74,7 +74,7 @@ impl<Block: BlockT> GrandpaJustification<Block> {
 			.iter()
 			.map(|signed| &signed.precommit)
 			.min_by_key(|precommit| precommit.target_number)
-			.map(|precommit| (precommit.target_hash.clone(), precommit.target_number))
+			.map(|precommit| (precommit.target_hash, precommit.target_number))
 		{
 			None => return error(),
 			Some(base) => base,
@@ -176,7 +176,7 @@ impl<Block: BlockT> GrandpaJustification<Block> {
 			.iter()
 			.map(|signed| &signed.precommit)
 			.min_by_key(|precommit| precommit.target_number)
-			.map(|precommit| precommit.target_hash.clone())
+			.map(|precommit| precommit.target_hash)
 			.expect(
 				"can only fail if precommits is empty; \
 				 commit has been validated above; \

substrate/client/finality-grandpa/src/tests.rs

@@ -170,7 +170,7 @@ pub(crate) struct RuntimeApi {
 impl ProvideRuntimeApi<Block> for TestApi {
 	type Api = RuntimeApi;
 
-	fn runtime_api<'a>(&'a self) -> ApiRef<'a, Self::Api> {
+	fn runtime_api(&self) -> ApiRef<'_, Self::Api> {
 		RuntimeApi { inner: self.clone() }.into()
 	}
 }
@@ -210,7 +210,7 @@ impl GenesisAuthoritySetProvider<Block> for TestApi {
 const TEST_GOSSIP_DURATION: Duration = Duration::from_millis(500);
 
 fn make_ids(keys: &[Ed25519Keyring]) -> AuthorityList {
-	keys.iter().map(|key| key.clone().public().into()).map(|id| (id, 1)).collect()
+	keys.iter().map(|&key| key.public().into()).map(|id| (id, 1)).collect()
 }
 
 fn create_keystore(authority: Ed25519Keyring) -> (SyncCryptoStorePtr, tempfile::TempDir) {
@@ -533,7 +533,7 @@ fn transition_3_voters_twice_1_full_observer() {
 	{
 		let net = net.clone();
 		let client = net.lock().peers[0].client().clone();
-		let peers_c = peers_c.clone();
+		let peers_c = *peers_c;
 
 		// wait for blocks to be finalized before generating new ones
 		let block_production = client

substrate/client/finality-grandpa/src/until_imported.rs

@@ -587,7 +587,7 @@ mod tests {
 
 		fn import_header(&self, header: Header) {
 			let hash = header.hash();
-			let number = header.number().clone();
+			let number = *header.number();
 
 			self.known_blocks.lock().insert(hash, number);
 			self.sender
@@ -608,7 +608,7 @@ mod tests {
 
 	impl BlockStatusT<Block> for TestBlockStatus {
 		fn block_number(&self, hash: Hash) -> Result<Option<u64>, Error> {
-			Ok(self.inner.lock().get(&hash).map(|x| x.clone()))
+			Ok(self.inner.lock().get(&hash).map(|x| *x))
 		}
 	}
 

substrate/client/finality-grandpa/src/voting_rule.rs

@@ -419,7 +419,7 @@ mod tests {
 		}
 
 		let best = client.header(&BlockId::Hash(client.info().best_hash)).unwrap().unwrap();
-		let best_number = best.number().clone();
+		let best_number = *best.number();
 
 		for i in 0u32..5 {
 			let base = client.header(&BlockId::Number(i.into())).unwrap().unwrap();

substrate/client/network-gossip/src/bridge.rs

@@ -520,7 +520,7 @@ mod tests {
 		// Register the remote peer.
 		event_sender
 			.start_send(Event::NotificationStreamOpened {
-				remote: remote_peer.clone(),
+				remote: remote_peer,
 				protocol: protocol.clone(),
 				negotiated_fallback: None,
 				role: ObservedRole::Authority,
@@ -532,7 +532,7 @@ mod tests {
 			.iter()
 			.cloned()
 			.map(|m| Event::NotificationsReceived {
-				remote: remote_peer.clone(),
+				remote: remote_peer,
 				messages: vec![(protocol.clone(), m.into())],
 			})
 			.collect::<Vec<_>>();
@@ -562,10 +562,7 @@ mod tests {
 			for subscriber in subscribers.iter_mut() {
 				assert_eq!(
 					subscriber.next(),
-					Some(TopicNotification {
-						message: message.clone(),
-						sender: Some(remote_peer.clone()),
-					}),
+					Some(TopicNotification { message: message.clone(), sender: Some(remote_peer) }),
 				);
 			}
 		}
@@ -661,7 +658,7 @@ mod tests {
 			// Create channels.
 			let (txs, mut rxs) = channels
 				.iter()
-				.map(|ChannelLengthAndTopic { length, topic }| (topic.clone(), channel(*length)))
+				.map(|ChannelLengthAndTopic { length, topic }| (*topic, channel(*length)))
 				.fold((vec![], vec![]), |mut acc, (topic, (tx, rx))| {
 					acc.0.push((topic, tx));
 					acc.1.push((topic, rx));
@@ -683,7 +680,7 @@ mod tests {
 			// Register the remote peer.
 			event_sender
 				.start_send(Event::NotificationStreamOpened {
-					remote: remote_peer.clone(),
+					remote: remote_peer,
 					protocol: protocol.clone(),
 					negotiated_fallback: None,
 					role: ObservedRole::Authority,
@@ -710,10 +707,7 @@ mod tests {
 					.collect();
 
 				event_sender
-					.start_send(Event::NotificationsReceived {
-						remote: remote_peer.clone(),
-						messages,
-					})
+					.start_send(Event::NotificationsReceived { remote: remote_peer, messages })
 					.expect("Event stream is unbounded; qed.");
 			}
 

substrate/client/network-gossip/src/state_machine.rs

@@ -810,7 +810,7 @@ mod tests {
 			.on_incoming(
 				&mut network,
 				// Unregistered peer.
-				remote.clone(),
+				remote,
 				vec![vec![1, 2, 3]],
 			);
 

substrate/client/network/src/discovery.rs

@@ -1069,7 +1069,7 @@ mod tests {
 					// Skip the first swarm as all other swarms already know it.
 					.skip(1)
 					.filter(|p| *p != n)
-					.map(|p| Swarm::local_peer_id(&swarms[p].0).clone())
+					.map(|p| *Swarm::local_peer_id(&swarms[p].0))
 					.collect::<HashSet<_>>()
 			})
 			.collect::<Vec<_>>();

substrate/client/network/sync/src/blocks.rs

@@ -290,51 +290,51 @@ mod test {
 		let peer2 = PeerId::random();
 
 		let blocks = generate_blocks(150);
-		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(1..41));
-		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(41..81));
-		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 0, 1, 200), Some(81..121));
+		assert_eq!(bc.needed_blocks(peer0, 40, 150, 0, 1, 200), Some(1..41));
+		assert_eq!(bc.needed_blocks(peer1, 40, 150, 0, 1, 200), Some(41..81));
+		assert_eq!(bc.needed_blocks(peer2, 40, 150, 0, 1, 200), Some(81..121));
 
 		bc.clear_peer_download(&peer1);
-		bc.insert(41, blocks[41..81].to_vec(), peer1.clone());
+		bc.insert(41, blocks[41..81].to_vec(), peer1);
 		assert_eq!(bc.ready_blocks(1), vec![]);
-		assert_eq!(bc.needed_blocks(peer1.clone(), 40, 150, 0, 1, 200), Some(121..151));
+		assert_eq!(bc.needed_blocks(peer1, 40, 150, 0, 1, 200), Some(121..151));
 		bc.clear_peer_download(&peer0);
-		bc.insert(1, blocks[1..11].to_vec(), peer0.clone());
+		bc.insert(1, blocks[1..11].to_vec(), peer0);
 
-		assert_eq!(bc.needed_blocks(peer0.clone(), 40, 150, 0, 1, 200), Some(11..41));
+		assert_eq!(bc.needed_blocks(peer0, 40, 150, 0, 1, 200), Some(11..41));
 		assert_eq!(
 			bc.ready_blocks(1),
 			blocks[1..11]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0) })
 				.collect::<Vec<_>>()
 		);
 
 		bc.clear_peer_download(&peer0);
-		bc.insert(11, blocks[11..41].to_vec(), peer0.clone());
+		bc.insert(11, blocks[11..41].to_vec(), peer0);
 
 		let ready = bc.ready_blocks(12);
 		assert_eq!(
 			ready[..30],
 			blocks[11..41]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer0.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0) })
 				.collect::<Vec<_>>()[..]
 		);
 		assert_eq!(
 			ready[30..],
 			blocks[41..81]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1) })
 				.collect::<Vec<_>>()[..]
 		);
 
 		bc.clear_peer_download(&peer2);
-		assert_eq!(bc.needed_blocks(peer2.clone(), 40, 150, 80, 1, 200), Some(81..121));
+		assert_eq!(bc.needed_blocks(peer2, 40, 150, 80, 1, 200), Some(81..121));
 		bc.clear_peer_download(&peer2);
-		bc.insert(81, blocks[81..121].to_vec(), peer2.clone());
+		bc.insert(81, blocks[81..121].to_vec(), peer2);
 		bc.clear_peer_download(&peer1);
-		bc.insert(121, blocks[121..150].to_vec(), peer1.clone());
+		bc.insert(121, blocks[121..150].to_vec(), peer1);
 
 		assert_eq!(bc.ready_blocks(80), vec![]);
 		let ready = bc.ready_blocks(81);
@@ -342,14 +342,14 @@ mod test {
 			ready[..40],
 			blocks[81..121]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer2.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer2) })
 				.collect::<Vec<_>>()[..]
 		);
 		assert_eq!(
 			ready[40..],
 			blocks[121..150]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer1.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1) })
 				.collect::<Vec<_>>()[..]
 		);
 	}
@@ -365,10 +365,10 @@ mod test {
 		bc.blocks.insert(114305, BlockRangeState::Complete(blocks));
 
 		let peer0 = PeerId::random();
-		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 000, 1, 200), Some(1..100));
-		assert_eq!(bc.needed_blocks(peer0.clone(), 128, 10000, 600, 1, 200), None); // too far ahead
+		assert_eq!(bc.needed_blocks(peer0, 128, 10000, 000, 1, 200), Some(1..100));
+		assert_eq!(bc.needed_blocks(peer0, 128, 10000, 600, 1, 200), None); // too far ahead
 		assert_eq!(
-			bc.needed_blocks(peer0.clone(), 128, 10000, 600, 1, 200000),
+			bc.needed_blocks(peer0, 128, 10000, 600, 1, 200000),
 			Some(100 + 128..100 + 128 + 128)
 		);
 	}
@@ -382,11 +382,11 @@ mod test {
 		let blocks = generate_blocks(10);
 
 		// count = 5, peer_best = 50, common = 39, max_parallel = 0, max_ahead = 200
-		assert_eq!(bc.needed_blocks(peer.clone(), 5, 50, 39, 0, 200), Some(40..45));
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(40..45));
 
 		// got a response on the request for `40..45`
 		bc.clear_peer_download(&peer);
-		bc.insert(40, blocks[..5].to_vec(), peer.clone());
+		bc.insert(40, blocks[..5].to_vec(), peer);
 
 		// our "node" started on a fork, with its current best = 47, which is > common
 		let ready = bc.ready_blocks(48);
@@ -394,11 +394,11 @@ mod test {
 			ready,
 			blocks[..5]
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer) })
 				.collect::<Vec<_>>()
 		);
 
-		assert_eq!(bc.needed_blocks(peer.clone(), 5, 50, 39, 0, 200), Some(45..50));
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(45..50));
 	}
 
 	#[test]
@@ -410,12 +410,12 @@ mod test {
 		let blocks = generate_blocks(10);
 
 		// Request 2 ranges
-		assert_eq!(bc.needed_blocks(peer.clone(), 5, 50, 39, 0, 200), Some(40..45));
-		assert_eq!(bc.needed_blocks(peer.clone(), 5, 50, 39, 0, 200), Some(45..50));
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(40..45));
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(45..50));
 
 		// got a response on the request for `40..50`
 		bc.clear_peer_download(&peer);
-		bc.insert(40, blocks.to_vec(), peer.clone());
+		bc.insert(40, blocks.to_vec(), peer);
 
 		// request any blocks starting from 1000 or lower.
 		let ready = bc.ready_blocks(1000);
@@ -423,7 +423,7 @@ mod test {
 			ready,
 			blocks
 				.iter()
-				.map(|b| BlockData { block: b.clone(), origin: Some(peer.clone()) })
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer) })
 				.collect::<Vec<_>>()
 		);
 

substrate/client/network/sync/src/extra_requests.rs

@@ -446,16 +446,12 @@ mod tests {
 					PeerSyncState::DownloadingJustification(r.0);
 			}
 
-			let active = requests
-				.active_requests
-				.iter()
-				.map(|(p, &r)| (p.clone(), r))
-				.collect::<Vec<_>>();
+			let active = requests.active_requests.iter().map(|(&p, &r)| (p, r)).collect::<Vec<_>>();
 
 			for (peer, req) in &active {
 				assert!(requests.failed_requests.get(req).is_none());
 				assert!(!requests.pending_requests.contains(req));
-				assert!(requests.on_response::<()>(peer.clone(), None).is_none());
+				assert!(requests.on_response::<()>(*peer, None).is_none());
 				assert!(requests.pending_requests.contains(req));
 				assert_eq!(
 					1,

substrate/client/network/sync/src/lib.rs

@@ -2614,15 +2614,15 @@ mod test {
 		let (b1_hash, b1_number) = new_blocks(50);
 
 		// add 2 peers at blocks that we don't have locally
-		sync.new_peer(peer_id1.clone(), Hash::random(), 42).unwrap();
-		sync.new_peer(peer_id2.clone(), Hash::random(), 10).unwrap();
+		sync.new_peer(peer_id1, Hash::random(), 42).unwrap();
+		sync.new_peer(peer_id2, Hash::random(), 10).unwrap();
 
 		// we wil send block requests to these peers
 		// for these blocks we don't know about
 		assert!(sync.block_requests().all(|(p, _)| { *p == peer_id1 || *p == peer_id2 }));
 
 		// add a new peer at a known block
-		sync.new_peer(peer_id3.clone(), b1_hash, b1_number).unwrap();
+		sync.new_peer(peer_id3, b1_hash, b1_number).unwrap();
 
 		// we request a justification for a block we have locally
 		sync.request_justification(&b1_hash, b1_number);
@@ -2673,7 +2673,7 @@ mod test {
 			data: Some(Vec::new()),
 		};
 
-		sync.push_block_announce_validation(peer_id.clone(), header.hash(), block_annnounce, true);
+		sync.push_block_announce_validation(*peer_id, header.hash(), block_annnounce, true);
 
 		// Poll until we have procssed the block announcement
 		block_on(poll_fn(|cx| loop {
@@ -2790,8 +2790,8 @@ mod test {
 		let block3_fork = build_block_at(block2.hash(), false);
 
 		// Add two peers which are on block 1.
-		sync.new_peer(peer_id1.clone(), block1.hash(), 1).unwrap();
-		sync.new_peer(peer_id2.clone(), block1.hash(), 1).unwrap();
+		sync.new_peer(peer_id1, block1.hash(), 1).unwrap();
+		sync.new_peer(peer_id2, block1.hash(), 1).unwrap();
 
 		// Tell sync that our best block is 3.
 		sync.update_chain_info(&block3.hash(), 3);
@@ -2885,9 +2885,9 @@ mod test {
 
 		let best_block = blocks.last().unwrap().clone();
 		// Connect the node we will sync from
-		sync.new_peer(peer_id1.clone(), best_block.hash(), *best_block.header().number())
+		sync.new_peer(peer_id1, best_block.hash(), *best_block.header().number())
 			.unwrap();
-		sync.new_peer(peer_id2.clone(), info.best_hash, 0).unwrap();
+		sync.new_peer(peer_id2, info.best_hash, 0).unwrap();
 
 		let mut best_block_num = 0;
 		while best_block_num < MAX_DOWNLOAD_AHEAD {
@@ -2922,9 +2922,9 @@ mod test {
 					.map(|b| {
 						(
 							Ok(BlockImportStatus::ImportedUnknown(
-								b.header().number().clone(),
+								*b.header().number(),
 								Default::default(),
-								Some(peer_id1.clone()),
+								Some(peer_id1),
 							)),
 							b.hash(),
 						)
@@ -3034,7 +3034,7 @@ mod test {
 
 		let common_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize / 2].clone();
 		// Connect the node we will sync from
-		sync.new_peer(peer_id1.clone(), common_block.hash(), *common_block.header().number())
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
 			.unwrap();
 
 		send_block_announce(fork_blocks.last().unwrap().header().clone(), &peer_id1, &mut sync);
@@ -3059,7 +3059,7 @@ mod test {
 		}
 
 		// Now request and import the fork.
-		let mut best_block_num = finalized_block.header().number().clone() as u32;
+		let mut best_block_num = *finalized_block.header().number() as u32;
 		while best_block_num < *fork_blocks.last().unwrap().header().number() as u32 - 1 {
 			let request = get_block_request(
 				&mut sync,
@@ -3092,9 +3092,9 @@ mod test {
 					.map(|b| {
 						(
 							Ok(BlockImportStatus::ImportedUnknown(
-								b.header().number().clone(),
+								*b.header().number(),
 								Default::default(),
-								Some(peer_id1.clone()),
+								Some(peer_id1),
 							)),
 							b.hash(),
 						)
@@ -3165,7 +3165,7 @@ mod test {
 
 		let common_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize / 2].clone();
 		// Connect the node we will sync from
-		sync.new_peer(peer_id1.clone(), common_block.hash(), *common_block.header().number())
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
 			.unwrap();
 
 		send_block_announce(fork_blocks.last().unwrap().header().clone(), &peer_id1, &mut sync);
@@ -3190,7 +3190,7 @@ mod test {
 		}
 
 		// Now request and import the fork.
-		let mut best_block_num = finalized_block.header().number().clone() as u32;
+		let mut best_block_num = *finalized_block.header().number() as u32;
 		let mut request = get_block_request(
 			&mut sync,
 			FromBlock::Number(MAX_BLOCKS_TO_REQUEST as u64 + best_block_num as u64),
@@ -3231,9 +3231,9 @@ mod test {
 				.map(|b| {
 					(
 						Ok(BlockImportStatus::ImportedUnknown(
-							b.header().number().clone(),
+							*b.header().number(),
 							Default::default(),
-							Some(peer_id1.clone()),
+							Some(peer_id1),
 						)),
 						b.hash(),
 					)
@@ -3288,7 +3288,7 @@ mod test {
 		let peer_id1 = PeerId::random();
 		let common_block = blocks[1].clone();
 		// Connect the node we will sync from
-		sync.new_peer(peer_id1.clone(), common_block.hash(), *common_block.header().number())
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
 			.unwrap();
 
 		// Create a "new" header and announce it
@@ -3320,7 +3320,7 @@ mod test {
 
 		let peer_id1 = PeerId::random();
 		let best_block = blocks[3].clone();
-		sync.new_peer(peer_id1.clone(), best_block.hash(), *best_block.header().number())
+		sync.new_peer(peer_id1, best_block.hash(), *best_block.header().number())
 			.unwrap();
 
 		sync.peers.get_mut(&peer_id1).unwrap().state = PeerSyncState::Available;

substrate/client/rpc/src/chain/tests.rs

@@ -40,7 +40,7 @@ async fn should_return_header() {
 		Header {
 			parent_hash: H256::from_low_u64_be(0),
 			number: 0,
-			state_root: res.state_root.clone(),
+			state_root: res.state_root,
 			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
 				.parse()
 				.unwrap(),
@@ -54,7 +54,7 @@ async fn should_return_header() {
 		Header {
 			parent_hash: H256::from_low_u64_be(0),
 			number: 0,
-			state_root: res.state_root.clone(),
+			state_root: res.state_root,
 			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
 				.parse()
 				.unwrap(),
@@ -93,7 +93,7 @@ async fn should_return_a_block() {
 			header: Header {
 				parent_hash: client.genesis_hash(),
 				number: 1,
-				state_root: res.block.header.state_root.clone(),
+				state_root: res.block.header.state_root,
 				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
 					.parse()
 					.unwrap(),
@@ -110,7 +110,7 @@ async fn should_return_a_block() {
 			header: Header {
 				parent_hash: client.genesis_hash(),
 				number: 1,
-				state_root: res.block.header.state_root.clone(),
+				state_root: res.block.header.state_root,
 				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
 					.parse()
 					.unwrap(),

substrate/client/service/test/src/client/mod.rs

@@ -410,7 +410,7 @@ fn best_containing_with_genesis_block() {
 
 	assert_eq!(
 		genesis_hash.clone(),
-		block_on(longest_chain_select.finality_target(genesis_hash.clone(), None)).unwrap(),
+		block_on(longest_chain_select.finality_target(genesis_hash, None)).unwrap(),
 	);
 }
 
@@ -1333,9 +1333,9 @@ fn respects_block_rules() {
 			.block;
 
 		let params = BlockCheckParams {
-			hash: block_ok.hash().clone(),
+			hash: block_ok.hash(),
 			number: 0,
-			parent_hash: block_ok.header().parent_hash().clone(),
+			parent_hash: *block_ok.header().parent_hash(),
 			allow_missing_state: false,
 			allow_missing_parent: false,
 			import_existing: false,
@@ -1349,9 +1349,9 @@ fn respects_block_rules() {
 		let block_not_ok = block_not_ok.build().unwrap().block;
 
 		let params = BlockCheckParams {
-			hash: block_not_ok.hash().clone(),
+			hash: block_not_ok.hash(),
 			number: 0,
-			parent_hash: block_not_ok.header().parent_hash().clone(),
+			parent_hash: *block_not_ok.header().parent_hash(),
 			allow_missing_state: false,
 			allow_missing_parent: false,
 			import_existing: false,
@@ -1372,15 +1372,15 @@ fn respects_block_rules() {
 		let block_ok = block_ok.build().unwrap().block;
 
 		let params = BlockCheckParams {
-			hash: block_ok.hash().clone(),
+			hash: block_ok.hash(),
 			number: 1,
-			parent_hash: block_ok.header().parent_hash().clone(),
+			parent_hash: *block_ok.header().parent_hash(),
 			allow_missing_state: false,
 			allow_missing_parent: false,
 			import_existing: false,
 		};
 		if record_only {
-			fork_rules.push((1, block_ok.hash().clone()));
+			fork_rules.push((1, block_ok.hash()));
 		}
 		assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
 
@@ -1391,9 +1391,9 @@ fn respects_block_rules() {
 		let block_not_ok = block_not_ok.build().unwrap().block;
 
 		let params = BlockCheckParams {
-			hash: block_not_ok.hash().clone(),
+			hash: block_not_ok.hash(),
 			number: 1,
-			parent_hash: block_not_ok.header().parent_hash().clone(),
+			parent_hash: *block_not_ok.header().parent_hash(),
 			allow_missing_state: false,
 			allow_missing_parent: false,
 			import_existing: false,
@@ -1457,9 +1457,9 @@ fn returns_status_for_pruned_blocks() {
 	let b1 = b1.build().unwrap().block;
 
 	let check_block_a1 = BlockCheckParams {
-		hash: a1.hash().clone(),
+		hash: a1.hash(),
 		number: 0,
-		parent_hash: a1.header().parent_hash().clone(),
+		parent_hash: *a1.header().parent_hash(),
 		allow_missing_state: false,
 		allow_missing_parent: false,
 		import_existing: false,
@@ -1494,9 +1494,9 @@ fn returns_status_for_pruned_blocks() {
 	block_on(client.import_as_final(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let check_block_a2 = BlockCheckParams {
-		hash: a2.hash().clone(),
+		hash: a2.hash(),
 		number: 1,
-		parent_hash: a1.header().parent_hash().clone(),
+		parent_hash: *a1.header().parent_hash(),
 		allow_missing_state: false,
 		allow_missing_parent: false,
 		import_existing: false,
@@ -1528,9 +1528,9 @@ fn returns_status_for_pruned_blocks() {
 
 	block_on(client.import_as_final(BlockOrigin::Own, a3.clone())).unwrap();
 	let check_block_a3 = BlockCheckParams {
-		hash: a3.hash().clone(),
+		hash: a3.hash(),
 		number: 2,
-		parent_hash: a2.header().parent_hash().clone(),
+		parent_hash: *a2.header().parent_hash(),
 		allow_missing_state: false,
 		allow_missing_parent: false,
 		import_existing: false,
@@ -1563,9 +1563,9 @@ fn returns_status_for_pruned_blocks() {
 	);
 
 	let mut check_block_b1 = BlockCheckParams {
-		hash: b1.hash().clone(),
+		hash: b1.hash(),
 		number: 0,
-		parent_hash: b1.header().parent_hash().clone(),
+		parent_hash: *b1.header().parent_hash(),
 		allow_missing_state: false,
 		allow_missing_parent: false,
 		import_existing: false,

substrate/client/transaction-pool/benches/basics.rs

@@ -66,7 +66,7 @@ impl ChainApi for TestApi {
 		uxt: <Self::Block as BlockT>::Extrinsic,
 	) -> Self::ValidationFuture {
 		let nonce = uxt.transfer().nonce;
-		let from = uxt.transfer().from.clone();
+		let from = uxt.transfer().from;
 
 		match self.block_id_to_number(at) {
 			Ok(Some(num)) if num > 5 => return ready(Ok(Err(InvalidTransaction::Stale.into()))),
@@ -76,7 +76,7 @@ impl ChainApi for TestApi {
 		ready(Ok(Ok(ValidTransaction {
 			priority: 4,
 			requires: if nonce > 1 && self.nonce_dependant {
-				vec![to_tag(nonce - 1, from.clone())]
+				vec![to_tag(nonce - 1, from)]
 			} else {
 				vec![]
 			},

substrate/client/transaction-pool/src/graph/pool.rs

@@ -641,7 +641,7 @@ mod tests {
 		.unwrap();
 
 		// when
-		block_on(pool.prune_tags(&BlockId::Number(1), vec![vec![0]], vec![hash1.clone()])).unwrap();
+		block_on(pool.prune_tags(&BlockId::Number(1), vec![vec![0]], vec![hash1])).unwrap();
 
 		// then
 		assert!(pool.validated_pool.is_banned(&hash1));
@@ -793,12 +793,8 @@ mod tests {
 			assert_eq!(pool.validated_pool().status().future, 0);
 
 			// when
-			block_on(pool.prune_tags(
-				&BlockId::Number(2),
-				vec![vec![0u8]],
-				vec![watcher.hash().clone()],
-			))
-			.unwrap();
+			block_on(pool.prune_tags(&BlockId::Number(2), vec![vec![0u8]], vec![*watcher.hash()]))
+				.unwrap();
 			assert_eq!(pool.validated_pool().status().ready, 0);
 			assert_eq!(pool.validated_pool().status().future, 0);
 

substrate/client/transaction-pool/src/graph/rotator.rs

@@ -120,7 +120,7 @@ mod tests {
 		let tx = Transaction {
 			data: (),
 			bytes: 1,
-			hash: hash.clone(),
+			hash,
 			priority: 5,
 			valid_till: 1,
 			requires: vec![],

substrate/client/transaction-pool/tests/pool.rs

@@ -387,7 +387,7 @@ fn should_push_watchers_during_maintenance() {
 	let header_hash = header.hash();
 	block_on(pool.maintain(block_event(header)));
 
-	let event = ChainEvent::Finalized { hash: header_hash.clone(), tree_route: Arc::from(vec![]) };
+	let event = ChainEvent::Finalized { hash: header_hash, tree_route: Arc::from(vec![]) };
 	block_on(pool.maintain(event));
 
 	// then
@@ -398,24 +398,24 @@ fn should_push_watchers_during_maintenance() {
 		futures::executor::block_on_stream(watcher0).collect::<Vec<_>>(),
 		vec![
 			TransactionStatus::Ready,
-			TransactionStatus::InBlock(header_hash.clone()),
-			TransactionStatus::Finalized(header_hash.clone())
+			TransactionStatus::InBlock(header_hash),
+			TransactionStatus::Finalized(header_hash)
 		],
 	);
 	assert_eq!(
 		futures::executor::block_on_stream(watcher1).collect::<Vec<_>>(),
 		vec![
 			TransactionStatus::Ready,
-			TransactionStatus::InBlock(header_hash.clone()),
-			TransactionStatus::Finalized(header_hash.clone())
+			TransactionStatus::InBlock(header_hash),
+			TransactionStatus::Finalized(header_hash)
 		],
 	);
 	assert_eq!(
 		futures::executor::block_on_stream(watcher2).collect::<Vec<_>>(),
 		vec![
 			TransactionStatus::Ready,
-			TransactionStatus::InBlock(header_hash.clone()),
-			TransactionStatus::Finalized(header_hash.clone())
+			TransactionStatus::InBlock(header_hash),
+			TransactionStatus::Finalized(header_hash)
 		],
 	);
 }
@@ -573,7 +573,7 @@ fn fork_aware_finalization() {
 	for (canon_watcher, h) in canon_watchers {
 		let mut stream = futures::executor::block_on_stream(canon_watcher);
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
-		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(h.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(h)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(h)));
 		assert_eq!(stream.next(), None);
 	}
@@ -581,22 +581,22 @@ fn fork_aware_finalization() {
 	{
 		let mut stream = futures::executor::block_on_stream(from_dave_watcher);
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
-		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(c2.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(c2)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(c2)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
 		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(e1)));
-		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(e1.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(e1)));
 		assert_eq!(stream.next(), None);
 	}
 
 	{
 		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
-		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(d2.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(d2)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(d2)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
 		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(e1)));
-		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(e1.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(e1)));
 		assert_eq!(stream.next(), None);
 	}
 }
@@ -646,9 +646,9 @@ fn prune_and_retract_tx_at_same_time() {
 	{
 		let mut stream = futures::executor::block_on_stream(watcher);
 		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
-		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(b1.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(b1)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b1)));
-		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(b2.clone())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock(b2)));
 		assert_eq!(stream.next(), Some(TransactionStatus::Finalized(b2)));
 		assert_eq!(stream.next(), None);
 	}
@@ -781,7 +781,7 @@ fn resubmit_from_retracted_fork() {
 	let e1 = {
 		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx4.clone()))
 			.expect("1. Imported");
-		let header = pool.api().push_block_with_parent(d1.clone(), vec![tx4.clone()], true);
+		let header = pool.api().push_block_with_parent(d1, vec![tx4.clone()], true);
 		assert_eq!(pool.status().ready, 2);
 		header.hash()
 	};
@@ -790,7 +790,7 @@ fn resubmit_from_retracted_fork() {
 	let f1_header = {
 		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx5.clone()))
 			.expect("1. Imported");
-		let header = pool.api().push_block_with_parent(e1.clone(), vec![tx5.clone()], true);
+		let header = pool.api().push_block_with_parent(e1, vec![tx5.clone()], true);
 		// Don't announce the block event to the pool directly, because we will
 		// re-org to this block.
 		assert_eq!(pool.status().ready, 3);

substrate/frame/alliance/src/tests.rs

@@ -76,7 +76,7 @@ fn vote_works() {
 			Box::new(proposal.clone()),
 			proposal_len
 		));
-		assert_ok!(Alliance::vote(Origin::signed(2), hash.clone(), 0, true));
+		assert_ok!(Alliance::vote(Origin::signed(2), hash, 0, true));
 
 		let record = |event| EventRecord { phase: Phase::Initialization, event, topics: vec![] };
 		assert_eq!(
@@ -85,12 +85,12 @@ fn vote_works() {
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Proposed {
 					account: 1,
 					proposal_index: 0,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					threshold: 3
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Voted {
 					account: 2,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					voted: true,
 					yes: 1,
 					no: 0,
@@ -114,7 +114,7 @@ fn veto_works() {
 		));
 		// only set_rule/elevate_ally can be veto
 		assert_noop!(
-			Alliance::veto(Origin::signed(1), hash.clone()),
+			Alliance::veto(Origin::signed(1), hash),
 			Error::<Test, ()>::NotVetoableProposal
 		);
 
@@ -131,11 +131,11 @@ fn veto_works() {
 
 		// only founder have veto rights, 3 is fellow
 		assert_noop!(
-			Alliance::veto(Origin::signed(3), vetoable_hash.clone()),
+			Alliance::veto(Origin::signed(3), vetoable_hash),
 			Error::<Test, ()>::NotFounder
 		);
 
-		assert_ok!(Alliance::veto(Origin::signed(2), vetoable_hash.clone()));
+		assert_ok!(Alliance::veto(Origin::signed(2), vetoable_hash));
 		let record = |event| EventRecord { phase: Phase::Initialization, event, topics: vec![] };
 		assert_eq!(
 			System::events(),
@@ -143,17 +143,17 @@ fn veto_works() {
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Proposed {
 					account: 1,
 					proposal_index: 0,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					threshold: 3
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Proposed {
 					account: 1,
 					proposal_index: 1,
-					proposal_hash: vetoable_hash.clone(),
+					proposal_hash: vetoable_hash,
 					threshold: 3
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Disapproved {
-					proposal_hash: vetoable_hash.clone()
+					proposal_hash: vetoable_hash
 				})),
 			]
 		);
@@ -173,16 +173,10 @@ fn close_works() {
 			Box::new(proposal.clone()),
 			proposal_len
 		));
-		assert_ok!(Alliance::vote(Origin::signed(1), hash.clone(), 0, true));
-		assert_ok!(Alliance::vote(Origin::signed(2), hash.clone(), 0, true));
-		assert_ok!(Alliance::vote(Origin::signed(3), hash.clone(), 0, true));
-		assert_ok!(Alliance::close(
-			Origin::signed(1),
-			hash.clone(),
-			0,
-			proposal_weight,
-			proposal_len
-		));
+		assert_ok!(Alliance::vote(Origin::signed(1), hash, 0, true));
+		assert_ok!(Alliance::vote(Origin::signed(2), hash, 0, true));
+		assert_ok!(Alliance::vote(Origin::signed(3), hash, 0, true));
+		assert_ok!(Alliance::close(Origin::signed(1), hash, 0, proposal_weight, proposal_len));
 
 		let record = |event| EventRecord { phase: Phase::Initialization, event, topics: vec![] };
 		assert_eq!(
@@ -191,40 +185,40 @@ fn close_works() {
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Proposed {
 					account: 1,
 					proposal_index: 0,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					threshold: 3
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Voted {
 					account: 1,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					voted: true,
 					yes: 1,
 					no: 0,
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Voted {
 					account: 2,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					voted: true,
 					yes: 2,
 					no: 0,
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Voted {
 					account: 3,
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					voted: true,
 					yes: 3,
 					no: 0,
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Closed {
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					yes: 3,
 					no: 0,
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Approved {
-					proposal_hash: hash.clone()
+					proposal_hash: hash
 				})),
 				record(mock::Event::AllianceMotion(AllianceMotionEvent::Executed {
-					proposal_hash: hash.clone(),
+					proposal_hash: hash,
 					result: Err(DispatchError::BadOrigin),
 				}))
 			]

substrate/frame/assets/src/mock.rs

@@ -115,11 +115,11 @@ thread_local! {
 pub struct TestFreezer;
 impl FrozenBalance<u32, u64, u64> for TestFreezer {
 	fn frozen_balance(asset: u32, who: &u64) -> Option<u64> {
-		FROZEN.with(|f| f.borrow().get(&(asset, who.clone())).cloned())
+		FROZEN.with(|f| f.borrow().get(&(asset, *who)).cloned())
 	}
 
 	fn died(asset: u32, who: &u64) {
-		HOOKS.with(|h| h.borrow_mut().push(Hook::Died(asset, who.clone())));
+		HOOKS.with(|h| h.borrow_mut().push(Hook::Died(asset, *who)));
 		// Sanity check: dead accounts have no balance.
 		assert!(Assets::balance(asset, *who).is_zero());
 	}

substrate/frame/atomic-swap/src/lib.rs

@@ -333,7 +333,7 @@ pub mod pallet {
 			);
 
 			swap.action.cancel(&swap.source);
-			PendingSwaps::<T>::remove(&target, hashed_proof.clone());
+			PendingSwaps::<T>::remove(&target, hashed_proof);
 
 			Self::deposit_event(Event::SwapCancelled { account: target, proof: hashed_proof });
 

substrate/frame/atomic-swap/src/tests.rs

@@ -102,7 +102,7 @@ fn two_party_successful_swap() {
 		AtomicSwap::create_swap(
 			Origin::signed(A),
 			B,
-			hashed_proof.clone(),
+			hashed_proof,
 			BalanceSwapAction::new(50),
 			1000,
 		)
@@ -117,7 +117,7 @@ fn two_party_successful_swap() {
 		AtomicSwap::create_swap(
 			Origin::signed(B),
 			A,
-			hashed_proof.clone(),
+			hashed_proof,
 			BalanceSwapAction::new(75),
 			1000,
 		)

substrate/frame/contracts/src/exec.rs

@@ -1416,12 +1416,7 @@ mod tests {
 				loader.counter += 1;
 				loader.map.insert(
 					hash,
-					MockExecutable {
-						func: Rc::new(f),
-						func_type,
-						code_hash: hash.clone(),
-						refcount: 1,
-					},
+					MockExecutable { func: Rc::new(f), func_type, code_hash: hash, refcount: 1 },
 				);
 				hash
 			})
@@ -2189,7 +2184,6 @@ mod tests {
 		let dummy_ch = MockLoader::insert(Call, |_, _| exec_success());
 		let instantiated_contract_address = Rc::new(RefCell::new(None::<AccountIdOf<Test>>));
 		let instantiator_ch = MockLoader::insert(Call, {
-			let dummy_ch = dummy_ch.clone();
 			let instantiated_contract_address = Rc::clone(&instantiated_contract_address);
 			move |ctx, _| {
 				// Instantiate a contract and save it's address in `instantiated_contract_address`.
@@ -2252,7 +2246,6 @@ mod tests {
 	fn instantiation_traps() {
 		let dummy_ch = MockLoader::insert(Constructor, |_, _| Err("It's a trap!".into()));
 		let instantiator_ch = MockLoader::insert(Call, {
-			let dummy_ch = dummy_ch.clone();
 			move |ctx, _| {
 				// Instantiate a contract and save it's address in `instantiated_contract_address`.
 				assert_matches!(

substrate/frame/contracts/src/tests.rs

@@ -139,7 +139,7 @@ impl TestExtension {
 	}
 
 	fn last_seen_inputs() -> (u32, u32, u32, u32) {
-		TEST_EXTENSION.with(|e| e.borrow().last_seen_inputs.clone())
+		TEST_EXTENSION.with(|e| e.borrow().last_seen_inputs)
 	}
 }
 
@@ -3478,8 +3478,8 @@ fn set_code_hash() {
 				phase: Phase::Initialization,
 				event: Event::Contracts(crate::Event::ContractCodeUpdated {
 					contract: contract_addr.clone(),
-					new_code_hash: new_code_hash.clone(),
-					old_code_hash: code_hash.clone(),
+					new_code_hash,
+					old_code_hash: code_hash,
 				}),
 				topics: vec![],
 			},

substrate/frame/contracts/src/wasm/mod.rs

@@ -403,7 +403,7 @@ mod tests {
 			salt: &[u8],
 		) -> Result<(AccountIdOf<Self::T>, ExecReturnValue), ExecError> {
 			self.instantiates.push(InstantiateEntry {
-				code_hash: code_hash.clone(),
+				code_hash,
 				value,
 				data: data.to_vec(),
 				gas_left: gas_limit,
@@ -541,7 +541,7 @@ mod tests {
 			signature: &[u8; 65],
 			message_hash: &[u8; 32],
 		) -> Result<[u8; 33], ()> {
-			self.ecdsa_recover.borrow_mut().push((signature.clone(), message_hash.clone()));
+			self.ecdsa_recover.borrow_mut().push((*signature, *message_hash));
 			Ok([3; 33])
 		}
 		fn contract_info(&mut self) -> &mut crate::ContractInfo<Self::T> {

substrate/frame/democracy/src/tests/external_proposing.rs

@@ -30,7 +30,7 @@ fn veto_external_works() {
 		assert!(<NextExternal<Test>>::exists());
 
 		let h = set_balance_proposal_hash_and_note(2);
-		assert_ok!(Democracy::veto_external(Origin::signed(3), h.clone()));
+		assert_ok!(Democracy::veto_external(Origin::signed(3), h));
 		// cancelled.
 		assert!(!<NextExternal<Test>>::exists());
 		// fails - same proposal can't be resubmitted.
@@ -55,13 +55,10 @@ fn veto_external_works() {
 		assert!(<NextExternal<Test>>::exists());
 
 		// 3 can't veto the same thing twice.
-		assert_noop!(
-			Democracy::veto_external(Origin::signed(3), h.clone()),
-			Error::<Test>::AlreadyVetoed
-		);
+		assert_noop!(Democracy::veto_external(Origin::signed(3), h), Error::<Test>::AlreadyVetoed);
 
 		// 4 vetoes.
-		assert_ok!(Democracy::veto_external(Origin::signed(4), h.clone()));
+		assert_ok!(Democracy::veto_external(Origin::signed(4), h));
 		// cancelled again.
 		assert!(!<NextExternal<Test>>::exists());
 

substrate/frame/democracy/src/tests/public_proposals.rs

@@ -115,7 +115,7 @@ fn blacklisting_should_work() {
 		assert_ok!(propose_set_balance_and_note(1, 2, 2));
 		assert_ok!(propose_set_balance_and_note(1, 4, 4));
 
-		assert_noop!(Democracy::blacklist(Origin::signed(1), hash.clone(), None), BadOrigin);
+		assert_noop!(Democracy::blacklist(Origin::signed(1), hash, None), BadOrigin);
 		assert_ok!(Democracy::blacklist(Origin::root(), hash, None));
 
 		assert_eq!(Democracy::backing_for(0), None);

substrate/frame/elections-phragmen/src/lib.rs

@@ -1342,9 +1342,7 @@ mod tests {
 			self
 		}
 		pub fn genesis_members(mut self, members: Vec<(u64, u64)>) -> Self {
-			MEMBERS.with(|m| {
-				*m.borrow_mut() = members.iter().map(|(m, _)| m.clone()).collect::<Vec<_>>()
-			});
+			MEMBERS.with(|m| *m.borrow_mut() = members.iter().map(|(m, _)| *m).collect::<Vec<_>>());
 			self.genesis_members = members;
 			self
 		}
@@ -1359,8 +1357,7 @@ mod tests {
 		pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
 			sp_tracing::try_init_simple();
 			MEMBERS.with(|m| {
-				*m.borrow_mut() =
-					self.genesis_members.iter().map(|(m, _)| m.clone()).collect::<Vec<_>>()
+				*m.borrow_mut() = self.genesis_members.iter().map(|(m, _)| *m).collect::<Vec<_>>()
 			});
 			let mut ext: sp_io::TestExternalities = GenesisConfig {
 				balances: pallet_balances::GenesisConfig::<Test> {

substrate/frame/examples/offchain-worker/src/tests.rs

@@ -253,10 +253,9 @@ fn should_submit_unsigned_transaction_on_chain_for_any_account() {
 	)
 	.unwrap();
 
-	let public_key = SyncCryptoStore::sr25519_public_keys(&keystore, crate::crypto::Public::ID)
+	let public_key = *SyncCryptoStore::sr25519_public_keys(&keystore, crate::crypto::Public::ID)
 		.get(0)
-		.unwrap()
-		.clone();
+		.unwrap();
 
 	let mut t = sp_io::TestExternalities::default();
 	t.register_extension(OffchainWorkerExt::new(offchain));
@@ -313,10 +312,9 @@ fn should_submit_unsigned_transaction_on_chain_for_all_accounts() {
 	)
 	.unwrap();
 
-	let public_key = SyncCryptoStore::sr25519_public_keys(&keystore, crate::crypto::Public::ID)
+	let public_key = *SyncCryptoStore::sr25519_public_keys(&keystore, crate::crypto::Public::ID)
 		.get(0)
-		.unwrap()
-		.clone();
+		.unwrap();
 
 	let mut t = sp_io::TestExternalities::default();
 	t.register_extension(OffchainWorkerExt::new(offchain));

substrate/frame/multisig/src/tests.rs

@@ -221,14 +221,7 @@ fn multisig_deposit_is_taken_and_returned_with_alt_call_storage() {
 		let data = call.encode();
 		let hash = blake2_256(&data);
 
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_eq!(Balances::free_balance(1), 1);
 		assert_eq!(Balances::reserved_balance(1), 4);
 
@@ -266,31 +259,18 @@ fn cancel_multisig_returns_deposit() {
 	new_test_ext().execute_with(|| {
 		let call = call_transfer(6, 15).encode();
 		let hash = blake2_256(&call);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_ok!(Multisig::approve_as_multi(
 			Origin::signed(2),
 			3,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_eq!(Balances::free_balance(1), 6);
 		assert_eq!(Balances::reserved_balance(1), 4);
-		assert_ok!(Multisig::cancel_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			now(),
-			hash.clone()
-		),);
+		assert_ok!(Multisig::cancel_as_multi(Origin::signed(1), 3, vec![2, 3], now(), hash),);
 		assert_eq!(Balances::free_balance(1), 10);
 		assert_eq!(Balances::reserved_balance(1), 0);
 	});
@@ -308,14 +288,7 @@ fn timepoint_checking_works() {
 		let hash = blake2_256(&call);
 
 		assert_noop!(
-			Multisig::approve_as_multi(
-				Origin::signed(2),
-				2,
-				vec![1, 3],
-				Some(now()),
-				hash.clone(),
-				0
-			),
+			Multisig::approve_as_multi(Origin::signed(2), 2, vec![1, 3], Some(now()), hash, 0),
 			Error::<Test>::UnexpectedTimepoint,
 		);
 
@@ -424,20 +397,13 @@ fn multisig_3_of_3_works() {
 		let call_weight = call.get_dispatch_info().weight;
 		let data = call.encode();
 		let hash = blake2_256(&data);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_ok!(Multisig::approve_as_multi(
 			Origin::signed(2),
 			3,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_eq!(Balances::free_balance(6), 0);
@@ -460,33 +426,20 @@ fn cancel_multisig_works() {
 	new_test_ext().execute_with(|| {
 		let call = call_transfer(6, 15).encode();
 		let hash = blake2_256(&call);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_ok!(Multisig::approve_as_multi(
 			Origin::signed(2),
 			3,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_noop!(
-			Multisig::cancel_as_multi(Origin::signed(2), 3, vec![1, 3], now(), hash.clone()),
+			Multisig::cancel_as_multi(Origin::signed(2), 3, vec![1, 3], now(), hash),
 			Error::<Test>::NotOwner,
 		);
-		assert_ok!(Multisig::cancel_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			now(),
-			hash.clone()
-		),);
+		assert_ok!(Multisig::cancel_as_multi(Origin::signed(1), 3, vec![2, 3], now(), hash),);
 	});
 }
 
@@ -510,20 +463,14 @@ fn cancel_multisig_with_call_storage_works() {
 			3,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_noop!(
-			Multisig::cancel_as_multi(Origin::signed(2), 3, vec![1, 3], now(), hash.clone()),
+			Multisig::cancel_as_multi(Origin::signed(2), 3, vec![1, 3], now(), hash),
 			Error::<Test>::NotOwner,
 		);
-		assert_ok!(Multisig::cancel_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			now(),
-			hash.clone()
-		),);
+		assert_ok!(Multisig::cancel_as_multi(Origin::signed(1), 3, vec![2, 3], now(), hash),);
 		assert_eq!(Balances::free_balance(1), 10);
 	});
 }
@@ -533,14 +480,7 @@ fn cancel_multisig_with_alt_call_storage_works() {
 	new_test_ext().execute_with(|| {
 		let call = call_transfer(6, 15).encode();
 		let hash = blake2_256(&call);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_eq!(Balances::free_balance(1), 6);
 		assert_ok!(Multisig::as_multi(
 			Origin::signed(2),
@@ -770,23 +710,9 @@ fn duplicate_approvals_are_ignored() {
 	new_test_ext().execute_with(|| {
 		let call = call_transfer(6, 15).encode();
 		let hash = blake2_256(&call);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			2,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 2, vec![2, 3], None, hash, 0));
 		assert_noop!(
-			Multisig::approve_as_multi(
-				Origin::signed(1),
-				2,
-				vec![2, 3],
-				Some(now()),
-				hash.clone(),
-				0
-			),
+			Multisig::approve_as_multi(Origin::signed(1), 2, vec![2, 3], Some(now()), hash, 0),
 			Error::<Test>::AlreadyApproved,
 		);
 		assert_ok!(Multisig::approve_as_multi(
@@ -794,18 +720,11 @@ fn duplicate_approvals_are_ignored() {
 			2,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_noop!(
-			Multisig::approve_as_multi(
-				Origin::signed(3),
-				2,
-				vec![1, 2],
-				Some(now()),
-				hash.clone(),
-				0
-			),
+			Multisig::approve_as_multi(Origin::signed(3), 2, vec![1, 2], Some(now()), hash, 0),
 			Error::<Test>::AlreadyApproved,
 		);
 	});
@@ -822,7 +741,7 @@ fn multisig_1_of_3_works() {
 		let call = call_transfer(6, 15).encode();
 		let hash = blake2_256(&call);
 		assert_noop!(
-			Multisig::approve_as_multi(Origin::signed(1), 1, vec![2, 3], None, hash.clone(), 0),
+			Multisig::approve_as_multi(Origin::signed(1), 1, vec![2, 3], None, hash, 0),
 			Error::<Test>::MinimumThreshold,
 		);
 		assert_noop!(
@@ -906,20 +825,13 @@ fn multisig_handles_no_preimage_after_all_approve() {
 		let call_weight = call.get_dispatch_info().weight;
 		let data = call.encode();
 		let hash = blake2_256(&data);
-		assert_ok!(Multisig::approve_as_multi(
-			Origin::signed(1),
-			3,
-			vec![2, 3],
-			None,
-			hash.clone(),
-			0
-		));
+		assert_ok!(Multisig::approve_as_multi(Origin::signed(1), 3, vec![2, 3], None, hash, 0));
 		assert_ok!(Multisig::approve_as_multi(
 			Origin::signed(2),
 			3,
 			vec![1, 3],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_ok!(Multisig::approve_as_multi(
@@ -927,7 +839,7 @@ fn multisig_handles_no_preimage_after_all_approve() {
 			3,
 			vec![1, 2],
 			Some(now()),
-			hash.clone(),
+			hash,
 			0
 		));
 		assert_eq!(Balances::free_balance(6), 0);

substrate/frame/nomination-pools/benchmarking/src/lib.rs

@@ -224,7 +224,7 @@ frame_benchmarking::benchmarks! {
 			origin_weight
 		);
 
-		let max_additional = scenario.dest_weight.clone() - origin_weight;
+		let max_additional = scenario.dest_weight - origin_weight;
 		let joiner_free = CurrencyOf::<T>::minimum_balance() + max_additional;
 
 		let joiner: T::AccountId
@@ -243,7 +243,7 @@ frame_benchmarking::benchmarks! {
 	bond_extra_transfer {
 		let origin_weight = min_create_bond::<T>() * 2u32.into();
 		let scenario = ListScenario::<T>::new(origin_weight, true)?;
-		let extra = scenario.dest_weight.clone() - origin_weight;
+		let extra = scenario.dest_weight - origin_weight;
 
 		// creator of the src pool will bond-extra, bumping itself to dest bag.
 
@@ -258,7 +258,7 @@ frame_benchmarking::benchmarks! {
 	bond_extra_reward {
 		let origin_weight = min_create_bond::<T>() * 2u32.into();
 		let scenario = ListScenario::<T>::new(origin_weight, true)?;
-		let extra = (scenario.dest_weight.clone() - origin_weight).max(CurrencyOf::<T>::minimum_balance());
+		let extra = (scenario.dest_weight - origin_weight).max(CurrencyOf::<T>::minimum_balance());
 
 		// transfer exactly `extra` to the depositor of the src pool (1),
 		let reward_account1 = Pools::<T>::create_reward_account(1);
@@ -306,7 +306,7 @@ frame_benchmarking::benchmarks! {
 		// significantly higher than the first position in a list (e.g. the first bag threshold).
 		let origin_weight = min_create_bond::<T>() * 200u32.into();
 		let scenario = ListScenario::<T>::new(origin_weight, false)?;
-		let amount = origin_weight - scenario.dest_weight.clone();
+		let amount = origin_weight - scenario.dest_weight;
 
 		let scenario = scenario.add_joiner(amount);
 		let member_id = scenario.origin1_member.unwrap().clone();
@@ -316,7 +316,7 @@ frame_benchmarking::benchmarks! {
 	verify {
 		let bonded_after = T::StakingInterface::active_stake(&scenario.origin1).unwrap();
 		// We at least went down to the destination bag
-		assert!(bonded_after <= scenario.dest_weight.clone());
+		assert!(bonded_after <= scenario.dest_weight);
 		let member = PoolMembers::<T>::get(
 			&member_id
 		)

substrate/frame/nomination-pools/src/lib.rs

@@ -491,7 +491,7 @@ impl<T: Config> PoolMember<T> {
 				true
 			} else {
 				removed_points
-					.try_insert(*e, p.clone())
+					.try_insert(*e, *p)
 					.expect("source map is bounded, this is a subset, will be bounded; qed");
 				false
 			}
@@ -1920,10 +1920,7 @@ pub mod pallet {
 			);
 			ReversePoolIdLookup::<T>::insert(bonded_pool.bonded_account(), pool_id);
 
-			Self::deposit_event(Event::<T>::Created {
-				depositor: who.clone(),
-				pool_id: pool_id.clone(),
-			});
+			Self::deposit_event(Event::<T>::Created { depositor: who.clone(), pool_id });
 
 			Self::deposit_event(Event::<T>::Bonded {
 				member: who,

substrate/frame/nomination-pools/src/migration.rs

@@ -244,7 +244,7 @@ pub mod v2 {
 								},
 							};
 
-							total_value_locked += bonded_pool.points_to_balance(points.clone());
+							total_value_locked += bonded_pool.points_to_balance(*points);
 							let portion = Perbill::from_rational(*points, bonded_pool.points);
 							let last_claim = portion * accumulated_reward;
 

substrate/frame/proxy/src/tests.rs

@@ -543,7 +543,7 @@ fn anonymous_works() {
 		let anon = Proxy::anonymous_account(&1, &ProxyType::Any, 0, None);
 		System::assert_last_event(
 			ProxyEvent::AnonymousCreated {
-				anonymous: anon.clone(),
+				anonymous: anon,
 				who: 1,
 				proxy_type: ProxyType::Any,
 				disambiguation_index: 0,

substrate/frame/remark/src/tests.rs

@@ -28,7 +28,7 @@ fn generates_event() {
 		let caller = 1;
 		let data = vec![0u8; 100];
 		System::set_block_number(System::block_number() + 1); //otherwise event won't be registered.
-		assert_ok!(Remark::<Test>::store(RawOrigin::Signed(caller.clone()).into(), data.clone(),));
+		assert_ok!(Remark::<Test>::store(RawOrigin::Signed(caller).into(), data.clone(),));
 		let events = System::events();
 		// this one we create as we expect it
 		let system_event: <Test as frame_system::Config>::Event = Event::Stored {
@@ -50,7 +50,7 @@ fn does_not_store_empty() {
 		let data = vec![];
 		System::set_block_number(System::block_number() + 1); //otherwise event won't be registered.
 		assert_noop!(
-			Remark::<Test>::store(RawOrigin::Signed(caller.clone()).into(), data.clone(),),
+			Remark::<Test>::store(RawOrigin::Signed(caller).into(), data.clone(),),
 			Error::<Test>::Empty
 		);
 		assert!(System::events().is_empty());

substrate/frame/scheduler/src/tests.rs

@@ -47,7 +47,7 @@ fn scheduling_with_preimages_works() {
 	new_test_ext().execute_with(|| {
 		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
 		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
-		let hashed = MaybeHashed::Hash(hash.clone());
+		let hashed = MaybeHashed::Hash(hash);
 		assert_ok!(Preimage::note_preimage(Origin::signed(0), call.encode()));
 		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), hashed));
 		assert!(Preimage::preimage_requested(&hash));
@@ -67,7 +67,7 @@ fn scheduling_with_preimage_postpones_correctly() {
 	new_test_ext().execute_with(|| {
 		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
 		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
-		let hashed = MaybeHashed::Hash(hash.clone());
+		let hashed = MaybeHashed::Hash(hash);
 
 		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), hashed));
 		assert!(Preimage::preimage_requested(&hash));

substrate/frame/staking/src/mock.rs

@@ -826,7 +826,7 @@ pub(crate) fn on_offence_now(
 pub(crate) fn add_slash(who: &AccountId) {
 	on_offence_now(
 		&[OffenceDetails {
-			offender: (who.clone(), Staking::eras_stakers(active_era(), who.clone())),
+			offender: (*who, Staking::eras_stakers(active_era(), *who)),
 			reporters: vec![],
 		}],
 		&[Perbill::from_percent(10)],

substrate/frame/staking/src/tests.rs

@@ -1082,10 +1082,7 @@ fn validator_payment_prefs_work() {
 	// This test will focus on validator payment.
 	ExtBuilder::default().build_and_execute(|| {
 		let commission = Perbill::from_percent(40);
-		<Validators<Test>>::insert(
-			&11,
-			ValidatorPrefs { commission: commission.clone(), ..Default::default() },
-		);
+		<Validators<Test>>::insert(&11, ValidatorPrefs { commission, ..Default::default() });
 
 		// Reward controller so staked ratio doesn't change.
 		<Payee<Test>>::insert(&11, RewardDestination::Controller);

substrate/frame/state-trie-migration/src/lib.rs

@@ -1253,7 +1253,7 @@ mod mock {
 
 			weight_sum += StateTrieMigration::on_initialize(System::block_number());
 
-			root = System::finalize().state_root().clone();
+			root = *System::finalize().state_root();
 			System::on_finalize(System::block_number());
 		}
 		(root, weight_sum)

substrate/frame/timestamp/src/mock.rs

@@ -101,7 +101,7 @@ pub(crate) fn clear_captured_moment() {
 }
 
 pub(crate) fn get_captured_moment() -> Option<Moment> {
-	CAPTURED_MOMENT.with(|x| x.borrow().clone())
+	CAPTURED_MOMENT.with(|x| *x.borrow())
 }
 
 pub(crate) fn new_test_ext() -> TestExternalities {

substrate/frame/tips/src/tests.rs

@@ -256,10 +256,10 @@ fn report_awesome_and_tip_works() {
 		);
 
 		let h = tip_hash();
-		assert_ok!(Tips::tip(Origin::signed(10), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10));
-		assert_noop!(Tips::tip(Origin::signed(9), h.clone(), 10), BadOrigin);
+		assert_ok!(Tips::tip(Origin::signed(10), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10));
+		assert_noop!(Tips::tip(Origin::signed(9), h, 10), BadOrigin);
 		System::set_block_number(2);
 		assert_ok!(Tips::close_tip(Origin::signed(100), h.into()));
 		assert_eq!(Balances::reserved_balance(0), 0);
@@ -276,9 +276,9 @@ fn report_awesome_from_beneficiary_and_tip_works() {
 		assert_eq!(Balances::reserved_balance(0), 12);
 		assert_eq!(Balances::free_balance(0), 88);
 		let h = BlakeTwo256::hash_of(&(BlakeTwo256::hash(b"awesome.dot"), 0u128));
-		assert_ok!(Tips::tip(Origin::signed(10), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10));
+		assert_ok!(Tips::tip(Origin::signed(10), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10));
 		System::set_block_number(2);
 		assert_ok!(Tips::close_tip(Origin::signed(100), h.into()));
 		assert_eq!(Balances::reserved_balance(0), 0);
@@ -300,11 +300,11 @@ fn close_tip_works() {
 
 		assert_eq!(last_event(), TipEvent::NewTip { tip_hash: h });
 
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
 
 		assert_noop!(Tips::close_tip(Origin::signed(0), h.into()), Error::<Test>::StillOpen);
 
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10));
 
 		assert_eq!(last_event(), TipEvent::TipClosing { tip_hash: h });
 
@@ -340,10 +340,10 @@ fn slash_tip_works() {
 		assert_eq!(last_event(), TipEvent::NewTip { tip_hash: h });
 
 		// can't remove from any origin
-		assert_noop!(Tips::slash_tip(Origin::signed(0), h.clone()), BadOrigin);
+		assert_noop!(Tips::slash_tip(Origin::signed(0), h), BadOrigin);
 
 		// can remove from root.
-		assert_ok!(Tips::slash_tip(Origin::root(), h.clone()));
+		assert_ok!(Tips::slash_tip(Origin::root(), h));
 		assert_eq!(last_event(), TipEvent::TipSlashed { tip_hash: h, finder: 0, deposit: 12 });
 
 		// tipper slashed
@@ -359,11 +359,11 @@ fn retract_tip_works() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_ok!(Tips::report_awesome(Origin::signed(0), b"awesome.dot".to_vec(), 3));
 		let h = tip_hash();
-		assert_ok!(Tips::tip(Origin::signed(10), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10));
-		assert_noop!(Tips::retract_tip(Origin::signed(10), h.clone()), Error::<Test>::NotFinder);
-		assert_ok!(Tips::retract_tip(Origin::signed(0), h.clone()));
+		assert_ok!(Tips::tip(Origin::signed(10), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10));
+		assert_noop!(Tips::retract_tip(Origin::signed(10), h), Error::<Test>::NotFinder);
+		assert_ok!(Tips::retract_tip(Origin::signed(0), h));
 		System::set_block_number(2);
 		assert_noop!(Tips::close_tip(Origin::signed(0), h.into()), Error::<Test>::UnknownTip);
 
@@ -371,10 +371,10 @@ fn retract_tip_works() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_ok!(Tips::tip_new(Origin::signed(10), b"awesome.dot".to_vec(), 3, 10));
 		let h = tip_hash();
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10));
-		assert_noop!(Tips::retract_tip(Origin::signed(0), h.clone()), Error::<Test>::NotFinder);
-		assert_ok!(Tips::retract_tip(Origin::signed(10), h.clone()));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10));
+		assert_noop!(Tips::retract_tip(Origin::signed(0), h), Error::<Test>::NotFinder);
+		assert_ok!(Tips::retract_tip(Origin::signed(10), h));
 		System::set_block_number(2);
 		assert_noop!(Tips::close_tip(Origin::signed(10), h.into()), Error::<Test>::UnknownTip);
 	});
@@ -386,8 +386,8 @@ fn tip_median_calculation_works() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_ok!(Tips::tip_new(Origin::signed(10), b"awesome.dot".to_vec(), 3, 0));
 		let h = tip_hash();
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 1000000));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 1000000));
 		System::set_block_number(2);
 		assert_ok!(Tips::close_tip(Origin::signed(0), h.into()));
 		assert_eq!(Balances::free_balance(3), 10);
@@ -400,13 +400,13 @@ fn tip_changing_works() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_ok!(Tips::tip_new(Origin::signed(10), b"awesome.dot".to_vec(), 3, 10000));
 		let h = tip_hash();
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 10000));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 10000));
-		assert_ok!(Tips::tip(Origin::signed(13), h.clone(), 0));
-		assert_ok!(Tips::tip(Origin::signed(14), h.clone(), 0));
-		assert_ok!(Tips::tip(Origin::signed(12), h.clone(), 1000));
-		assert_ok!(Tips::tip(Origin::signed(11), h.clone(), 100));
-		assert_ok!(Tips::tip(Origin::signed(10), h.clone(), 10));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 10000));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 10000));
+		assert_ok!(Tips::tip(Origin::signed(13), h, 0));
+		assert_ok!(Tips::tip(Origin::signed(14), h, 0));
+		assert_ok!(Tips::tip(Origin::signed(12), h, 1000));
+		assert_ok!(Tips::tip(Origin::signed(11), h, 100));
+		assert_ok!(Tips::tip(Origin::signed(10), h, 10));
 		System::set_block_number(2);
 		assert_ok!(Tips::close_tip(Origin::signed(0), h.into()));
 		assert_eq!(Balances::free_balance(3), 10);
@@ -595,10 +595,10 @@ fn report_awesome_and_tip_works_second_instance() {
 		assert_ok!(Tips::report_awesome(Origin::signed(0), b"awesome.dot".to_vec(), 3));
 
 		let h = tip_hash();
-		assert_ok!(Tips1::tip(Origin::signed(10), h.clone(), 10));
-		assert_ok!(Tips1::tip(Origin::signed(11), h.clone(), 10));
-		assert_ok!(Tips1::tip(Origin::signed(12), h.clone(), 10));
-		assert_noop!(Tips1::tip(Origin::signed(9), h.clone(), 10), BadOrigin);
+		assert_ok!(Tips1::tip(Origin::signed(10), h, 10));
+		assert_ok!(Tips1::tip(Origin::signed(11), h, 10));
+		assert_ok!(Tips1::tip(Origin::signed(12), h, 10));
+		assert_noop!(Tips1::tip(Origin::signed(9), h, 10), BadOrigin);
 
 		System::set_block_number(2);
 

substrate/frame/transaction-payment/src/lib.rs

@@ -1042,8 +1042,8 @@ mod tests {
 					&Ok(())
 				));
 				assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
-				assert_eq!(FEE_UNBALANCED_AMOUNT.with(|a| a.borrow().clone()), 5 + 5 + 10);
-				assert_eq!(TIP_UNBALANCED_AMOUNT.with(|a| a.borrow().clone()), 0);
+				assert_eq!(FEE_UNBALANCED_AMOUNT.with(|a| *a.borrow()), 5 + 5 + 10);
+				assert_eq!(TIP_UNBALANCED_AMOUNT.with(|a| *a.borrow()), 0);
 
 				FEE_UNBALANCED_AMOUNT.with(|a| *a.borrow_mut() = 0);
 
@@ -1060,8 +1060,8 @@ mod tests {
 					&Ok(())
 				));
 				assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 50 - 5);
-				assert_eq!(FEE_UNBALANCED_AMOUNT.with(|a| a.borrow().clone()), 5 + 10 + 50);
-				assert_eq!(TIP_UNBALANCED_AMOUNT.with(|a| a.borrow().clone()), 5);
+				assert_eq!(FEE_UNBALANCED_AMOUNT.with(|a| *a.borrow()), 5 + 10 + 50);
+				assert_eq!(TIP_UNBALANCED_AMOUNT.with(|a| *a.borrow()), 5);
 			});
 	}
 

substrate/frame/transaction-storage/src/tests.rs

@@ -31,11 +31,11 @@ fn discards_data() {
 		run_to_block(1, || None);
 		let caller = 1;
 		assert_ok!(TransactionStorage::<Test>::store(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			vec![0u8; 2000 as usize]
 		));
 		assert_ok!(TransactionStorage::<Test>::store(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			vec![0u8; 2000 as usize]
 		));
 		let proof_provider = || {
@@ -74,7 +74,7 @@ fn burns_fee() {
 			Error::<Test>::InsufficientFunds,
 		);
 		assert_ok!(TransactionStorage::<Test>::store(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			vec![0u8; 2000 as usize]
 		));
 		assert_eq!(Balances::free_balance(1), 1_000_000_000 - 2000 * 2 - 200);
@@ -87,7 +87,7 @@ fn checks_proof() {
 		run_to_block(1, || None);
 		let caller = 1;
 		assert_ok!(TransactionStorage::<Test>::store(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			vec![0u8; MAX_DATA_SIZE as usize]
 		));
 		run_to_block(10, || None);
@@ -119,13 +119,13 @@ fn renews_data() {
 		run_to_block(1, || None);
 		let caller = 1;
 		assert_ok!(TransactionStorage::<Test>::store(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			vec![0u8; 2000]
 		));
 		let info = BlockTransactions::<Test>::get().last().unwrap().clone();
 		run_to_block(6, || None);
 		assert_ok!(TransactionStorage::<Test>::renew(
-			RawOrigin::Signed(caller.clone()).into(),
+			RawOrigin::Signed(caller).into(),
 			1, // block
 			0, // transaction
 		));

substrate/frame/uniques/src/functions.rs

@@ -234,15 +234,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		ensure!(details.owner == sender, Error::<T, I>::NoPermission);
 
 		if let Some(ref price) = price {
-			ItemPriceOf::<T, I>::insert(
-				&collection,
-				&item,
-				(price.clone(), whitelisted_buyer.clone()),
-			);
+			ItemPriceOf::<T, I>::insert(&collection, &item, (price, whitelisted_buyer.clone()));
 			Self::deposit_event(Event::ItemPriceSet {
 				collection,
 				item,
-				price: price.clone(),
+				price: *price,
 				whitelisted_buyer,
 			});
 		} else {

substrate/primitives/api/test/tests/runtime_calls.rs

@@ -148,10 +148,8 @@ fn record_proof_works() {
 		.build_with_longest_chain();
 
 	let block_id = BlockId::Number(client.chain_info().best_number);
-	let storage_root = futures::executor::block_on(longest_chain.best_chain())
-		.unwrap()
-		.state_root()
-		.clone();
+	let storage_root =
+		*futures::executor::block_on(longest_chain.best_chain()).unwrap().state_root();
 
 	let runtime_code = sp_core::traits::RuntimeCode {
 		code_fetcher: &sp_core::traits::WrappedRuntimeCode(

substrate/primitives/npos-elections/fuzzer/src/reduce.rs

@@ -90,7 +90,7 @@ fn generate_random_phragmen_assignment(
 				let target =
 					targets_to_chose_from.remove(rng.gen_range(0..targets_to_chose_from.len()));
 				if winners.iter().all(|w| *w != target) {
-					winners.push(target.clone());
+					winners.push(target);
 				}
 				(target, rng.gen_range(1 * KSM..100 * KSM))
 			})

substrate/primitives/npos-elections/src/mock.rs

@@ -92,7 +92,7 @@ where
 		.into_iter()
 		.enumerate()
 		.map(|(idx, who)| {
-			c_idx_cache.insert(who.clone(), idx);
+			c_idx_cache.insert(who, idx);
 			_Candidate { who, ..Default::default() }
 		})
 		.collect::<Vec<_Candidate<A>>>();
@@ -103,7 +103,7 @@ where
 		for v in votes {
 			if let Some(idx) = c_idx_cache.get(&v) {
 				candidates[*idx].approval_stake = candidates[*idx].approval_stake + voter_stake;
-				edges.push(_Edge { who: v.clone(), candidate_index: *idx, ..Default::default() });
+				edges.push(_Edge { who: v, candidate_index: *idx, ..Default::default() });
 			}
 		}
 		_Voter { who, edges, budget: voter_stake, load: 0f64 }
@@ -143,21 +143,21 @@ where
 				}
 			}
 
-			elected_candidates.push((winner.who.clone(), winner.approval_stake as ExtendedBalance));
+			elected_candidates.push((winner.who, winner.approval_stake as ExtendedBalance));
 		} else {
 			break
 		}
 	}
 
 	for n in &mut voters {
-		let mut assignment = (n.who.clone(), vec![]);
+		let mut assignment = (n.who, vec![]);
 		for e in &mut n.edges {
 			if let Some(c) =
 				elected_candidates.iter().cloned().map(|(c, _)| c).find(|c| *c == e.who)
 			{
 				if c != n.who {
 					let ratio = e.load / n.load;
-					assignment.1.push((e.who.clone(), ratio));
+					assignment.1.push((e.who, ratio));
 				}
 			}
 		}
@@ -321,7 +321,7 @@ pub(crate) fn run_and_compare<Output: PerThing128, FS>(
 		candidates.clone(),
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -368,7 +368,7 @@ pub(crate) fn build_support_map_float(
 	let mut supports = <_SupportMap<AccountId>>::new();
 	result.winners.iter().map(|(e, _)| (e, stake_of(e) as f64)).for_each(|(e, s)| {
 		let item = _Support { own: s, total: s, ..Default::default() };
-		supports.insert(e.clone(), item);
+		supports.insert(*e, item);
 	});
 
 	for (n, assignment) in result.assignments.iter_mut() {
@@ -377,7 +377,7 @@ pub(crate) fn build_support_map_float(
 			let other_stake = nominator_stake * *r;
 			if let Some(support) = supports.get_mut(c) {
 				support.total = support.total + other_stake;
-				support.others.push((n.clone(), other_stake));
+				support.others.push((*n, other_stake));
 			}
 			*r = other_stake;
 		}

substrate/primitives/npos-elections/src/pjr.rs

@@ -481,7 +481,7 @@ mod tests {
 		assert_eq!(
 			candidates
 				.iter()
-				.map(|c| (c.borrow().who.clone(), c.borrow().elected, c.borrow().backed_stake))
+				.map(|c| (c.borrow().who, c.borrow().elected, c.borrow().backed_stake))
 				.collect::<Vec<_>>(),
 			vec![(10, false, 0), (20, true, 15), (30, false, 0), (40, true, 15)],
 		);

substrate/primitives/npos-elections/src/tests.rs

@@ -233,7 +233,7 @@ fn phragmen_poc_works() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -289,7 +289,7 @@ fn phragmen_poc_works_with_balancing() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		Some(config),
 	)
@@ -376,7 +376,7 @@ fn phragmen_accuracy_on_large_scale_only_candidates() {
 		candidates.clone(),
 		auto_generate_self_voters(&candidates)
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -407,7 +407,7 @@ fn phragmen_accuracy_on_large_scale_voters_and_candidates() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -439,7 +439,7 @@ fn phragmen_accuracy_on_small_scale_self_vote() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -469,7 +469,7 @@ fn phragmen_accuracy_on_small_scale_no_self_vote() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -505,7 +505,7 @@ fn phragmen_large_scale_test() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -532,7 +532,7 @@ fn phragmen_large_scale_test_2() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -601,7 +601,7 @@ fn elect_has_no_entry_barrier() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -622,7 +622,7 @@ fn phragmen_self_votes_should_be_kept() {
 		candidates,
 		voters
 			.iter()
-			.map(|(ref v, ref vs)| (v.clone(), stake_of(v), vs.clone()))
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
 			.collect::<Vec<_>>(),
 		None,
 	)
@@ -872,30 +872,15 @@ mod score {
 		let claim =
 			[12488167277027543u128, 5559266368032409496, 118700736389524721358337889258988054];
 
-		assert_eq!(
-			is_score_better(claim.clone(), initial.clone(), Perbill::from_rational(1u32, 10_000),),
-			true,
-		);
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(1u32, 10_000),), true,);
 
-		assert_eq!(
-			is_score_better(claim.clone(), initial.clone(), Perbill::from_rational(2u32, 10_000),),
-			true,
-		);
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(2u32, 10_000),), true,);
 
-		assert_eq!(
-			is_score_better(claim.clone(), initial.clone(), Perbill::from_rational(3u32, 10_000),),
-			true,
-		);
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(3u32, 10_000),), true,);
 
-		assert_eq!(
-			is_score_better(claim.clone(), initial.clone(), Perbill::from_rational(4u32, 10_000),),
-			true,
-		);
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(4u32, 10_000),), true,);
 
-		assert_eq!(
-			is_score_better(claim.clone(), initial.clone(), Perbill::from_rational(5u32, 10_000),),
-			false,
-		);
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(5u32, 10_000),), false,);
 	}
 
 	#[test]

substrate/primitives/runtime/src/curve.rs

@@ -170,7 +170,7 @@ fn test_calculate_for_fraction_times_denominator() {
 	};
 
 	pub fn formal_calculate_for_fraction_times_denominator(n: u64, d: u64) -> u64 {
-		if n <= Perbill::from_parts(0_500_000_000) * d.clone() {
+		if n <= Perbill::from_parts(0_500_000_000) * d {
 			n + d / 2
 		} else {
 			(d as u128 * 2 - n as u128 * 2).try_into().unwrap()

substrate/primitives/runtime/src/lib.rs

@@ -1118,7 +1118,7 @@ mod tests {
 		ext.insert(b"c".to_vec(), vec![3u8; 33]);
 		ext.insert(b"d".to_vec(), vec![4u8; 33]);
 
-		let pre_root = ext.backend.root().clone();
+		let pre_root = *ext.backend.root();
 		let (_, proof) = ext.execute_and_prove(|| {
 			sp_io::storage::get(b"a");
 			sp_io::storage::get(b"b");