Merge pull request #2049 from douglaz/run-clippy-fix

Run clippy fix

Author: TheBlueMatt

lightning-background-processor/src/lib.rs

@@ -757,7 +757,7 @@ mod tests {
 
 	impl Persister {
 		fn new(data_dir: String) -> Self {
-			let filesystem_persister = FilesystemPersister::new(data_dir.clone());
+			let filesystem_persister = FilesystemPersister::new(data_dir);
 			Self { graph_error: None, graph_persistence_notifier: None, manager_error: None, scorer_error: None, filesystem_persister }
 		}
 
@@ -824,7 +824,7 @@ mod tests {
 		}
 
 		fn expect(&mut self, expectation: TestResult) {
-			self.event_expectations.get_or_insert_with(|| VecDeque::new()).push_back(expectation);
+			self.event_expectations.get_or_insert_with(VecDeque::new).push_back(expectation);
 		}
 	}
 
@@ -1226,7 +1226,7 @@ mod tests {
 		// Set up a background event handler for SpendableOutputs events.
 		let (sender, receiver) = std::sync::mpsc::sync_channel(1);
 		let event_handler = move |event: Event| match event {
-			Event::SpendableOutputs { .. } => sender.send(event.clone()).unwrap(),
+			Event::SpendableOutputs { .. } => sender.send(event).unwrap(),
 			Event::ChannelReady { .. } => {},
 			Event::ChannelClosed { .. } => {},
 			_ => panic!("Unexpected event: {:?}", event),
@@ -1274,7 +1274,7 @@ mod tests {
 		let nodes = create_nodes(2, "test_not_pruning_network_graph_until_graph_sync_completion".to_string());
 		let data_dir = nodes[0].persister.get_data_dir();
 		let (sender, receiver) = std::sync::mpsc::sync_channel(1);
-		let persister = Arc::new(Persister::new(data_dir.clone()).with_graph_persistence_notifier(sender));
+		let persister = Arc::new(Persister::new(data_dir).with_graph_persistence_notifier(sender));
 		let network_graph = nodes[0].network_graph.clone();
 		let features = ChannelFeatures::empty();
 		network_graph.add_channel_from_partial_announcement(42, 53, features, nodes[0].node.get_our_node_id(), nodes[1].node.get_our_node_id())
@@ -1317,7 +1317,7 @@ mod tests {
 		// this should have added two channels
 		assert_eq!(network_graph.read_only().channels().len(), 3);
 
-		let _ = receiver
+		receiver
 			.recv_timeout(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER * 5))
 			.expect("Network graph not pruned within deadline");
 
@@ -1344,7 +1344,7 @@ mod tests {
 
 		let nodes = create_nodes(1, "test_payment_path_scoring".to_string());
 		let data_dir = nodes[0].persister.get_data_dir();
-		let persister = Arc::new(Persister::new(data_dir.clone()));
+		let persister = Arc::new(Persister::new(data_dir));
 		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].no_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), Some(nodes[0].scorer.clone()));
 
 		let scored_scid = 4242;
@@ -1431,7 +1431,7 @@ mod tests {
 		nodes[0].node.push_pending_event(Event::ProbeFailed {
 			payment_id: PaymentId([42; 32]),
 			payment_hash: PaymentHash([42; 32]),
-			path: path.clone(),
+			path,
 			short_channel_id: Some(scored_scid),
 		});
 		let event = receiver

lightning-block-sync/src/init.rs

@@ -181,7 +181,7 @@ pub async fn synchronize_listeners<B: Deref + Sized + Send + Sync, C: Cache, L:
 		let chain_listener = &ChainListenerSet(chain_listeners_at_height);
 		let mut chain_notifier = ChainNotifier { header_cache, chain_listener };
 		chain_notifier.connect_blocks(common_ancestor, most_connected_blocks, &mut chain_poller)
-			.await.or_else(|(e, _)| Err(e))?;
+			.await.map_err(|(e, _)| e)?;
 	}
 
 	Ok(best_header)

lightning-block-sync/src/lib.rs

@@ -414,15 +414,15 @@ impl<'a, C: Cache, L: Deref> ChainNotifier<'a, C, L> where L::Target: chain::Lis
 			let height = header.height;
 			let block_data = chain_poller
 				.fetch_block(&header).await
-				.or_else(|e| Err((e, Some(new_tip))))?;
+				.map_err(|e| (e, Some(new_tip)))?;
 			debug_assert_eq!(block_data.block_hash, header.block_hash);
 
 			match block_data.deref() {
 				BlockData::FullBlock(block) => {
-					self.chain_listener.block_connected(&block, height);
+					self.chain_listener.block_connected(block, height);
 				},
 				BlockData::HeaderOnly(header) => {
-					self.chain_listener.filtered_block_connected(&header, &[], height);
+					self.chain_listener.filtered_block_connected(header, &[], height);
 				},
 			}
 

lightning-block-sync/src/poll.rs

@@ -61,7 +61,7 @@ impl Validate for BlockHeaderData {
 	fn validate(self, block_hash: BlockHash) -> BlockSourceResult<Self::T> {
 		let pow_valid_block_hash = self.header
 			.validate_pow(&self.header.target())
-			.or_else(|e| Err(BlockSourceError::persistent(e)))?;
+			.map_err(BlockSourceError::persistent)?;
 
 		if pow_valid_block_hash != block_hash {
 			return Err(BlockSourceError::persistent("invalid block hash"));
@@ -82,7 +82,7 @@ impl Validate for BlockData {
 
 		let pow_valid_block_hash = header
 			.validate_pow(&header.target())
-			.or_else(|e| Err(BlockSourceError::persistent(e)))?;
+			.map_err(BlockSourceError::persistent)?;
 
 		if pow_valid_block_hash != block_hash {
 			return Err(BlockSourceError::persistent("invalid block hash"));

lightning-block-sync/src/test_utils.rs

@@ -106,7 +106,7 @@ impl Blockchain {
 		BlockHeaderData {
 			chainwork: self.blocks[0].header.work() + Uint256::from_u64(height as u64).unwrap(),
 			height: height as u32,
-			header: self.blocks[height].header.clone(),
+			header: self.blocks[height].header,
 		}
 	}
 
@@ -162,7 +162,7 @@ impl BlockSource for Blockchain {
 					}
 
 					if self.filtered_blocks {
-						return Ok(BlockData::HeaderOnly(block.header.clone()));
+						return Ok(BlockData::HeaderOnly(block.header));
 					} else {
 						return Ok(BlockData::FullBlock(block.clone()));
 					}

lightning-invoice/src/de.rs

@@ -6,7 +6,6 @@ use core::num::ParseIntError;
 use core::str;
 use core::str::FromStr;
 
-use bech32;
 use bech32::{u5, FromBase32};
 
 use bitcoin_hashes::Hash;
@@ -18,7 +17,6 @@ use lightning::routing::router::{RouteHint, RouteHintHop};
 
 use num_traits::{CheckedAdd, CheckedMul};
 
-use secp256k1;
 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
 use secp256k1::PublicKey;
 
@@ -323,9 +321,9 @@ impl FromStr for RawHrp {
 		};
 
 		Ok(RawHrp {
-			currency: currency,
+			currency,
 			raw_amount: amount,
-			si_prefix: si_prefix,
+			si_prefix,
 		})
 	}
 }
@@ -342,7 +340,7 @@ impl FromBase32 for RawDataPart {
 		let tagged = parse_tagged_parts(&data[7..])?;
 
 		Ok(RawDataPart {
-			timestamp: timestamp,
+			timestamp,
 			tagged_fields: tagged,
 		})
 	}
@@ -515,7 +513,7 @@ impl FromBase32 for ExpiryTime {
 
 	fn from_base32(field_data: &[u5]) -> Result<ExpiryTime, ParseError> {
 		match parse_int_be::<u64, u5>(field_data, 32)
-			.map(|t| ExpiryTime::from_seconds(t))
+			.map(ExpiryTime::from_seconds)
 		{
 			Some(t) => Ok(t),
 			None => Err(ParseError::IntegerOverflowError),
@@ -540,7 +538,7 @@ impl FromBase32 for Fallback {
 	type Err = ParseError;
 
 	fn from_base32(field_data: &[u5]) -> Result<Fallback, ParseError> {
-		if field_data.len() < 1 {
+		if field_data.is_empty() {
 			return Err(ParseError::UnexpectedEndOfTaggedFields);
 		}
 
@@ -554,7 +552,7 @@ impl FromBase32 for Fallback {
 				}
 
 				Ok(Fallback::SegWitProgram {
-					version: version,
+					version,
 					program: bytes
 				})
 			},

lightning-invoice/src/lib.rs

@@ -585,13 +585,13 @@ impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, tb
 		}).collect::<Vec<_>>();
 
 		let data = RawDataPart {
-			timestamp: timestamp,
-			tagged_fields: tagged_fields,
+			timestamp,
+			tagged_fields,
 		};
 
 		Ok(RawInvoice {
-			hrp: hrp,
-			data: data,
+			hrp,
+			data,
 		})
 	}
 }
@@ -781,7 +781,7 @@ impl SignedRawInvoice {
 			recovered_pub_key = Some(recovered);
 		}
 
-		let pub_key = included_pub_key.or_else(|| recovered_pub_key.as_ref())
+		let pub_key = included_pub_key.or(recovered_pub_key.as_ref())
 			.expect("One is always present");
 
 		let hash = Message::from_slice(&self.hash[..])
@@ -1014,9 +1014,9 @@ impl PositiveTimestamp {
 }
 
 #[cfg(feature = "std")]
-impl Into<SystemTime> for PositiveTimestamp {
-	fn into(self) -> SystemTime {
-		SystemTime::UNIX_EPOCH + self.0
+impl From<PositiveTimestamp> for SystemTime {
+	fn from(val: PositiveTimestamp) -> Self {
+		SystemTime::UNIX_EPOCH + val.0
 	}
 }
 
@@ -1147,7 +1147,7 @@ impl Invoice {
 	/// ```
 	pub fn from_signed(signed_invoice: SignedRawInvoice) -> Result<Self, SemanticError> {
 		let invoice = Invoice {
-			signed_invoice: signed_invoice,
+			signed_invoice,
 		};
 		invoice.check_field_counts()?;
 		invoice.check_feature_bits()?;
@@ -1185,9 +1185,9 @@ impl Invoice {
 	///
 	/// (C-not exported) because we don't yet export InvoiceDescription
 	pub fn description(&self) -> InvoiceDescription {
-		if let Some(ref direct) = self.signed_invoice.description() {
+		if let Some(direct) = self.signed_invoice.description() {
 			return InvoiceDescription::Direct(direct);
-		} else if let Some(ref hash) = self.signed_invoice.description_hash() {
+		} else if let Some(hash) = self.signed_invoice.description_hash() {
 			return InvoiceDescription::Hash(hash);
 		}
 		unreachable!("ensured by constructor");
@@ -1332,9 +1332,9 @@ impl Description {
 	}
 }
 
-impl Into<String> for Description {
-	fn into(self) -> String {
-		self.into_inner()
+impl From<Description> for String {
+	fn from(val: Description) -> Self {
+		val.into_inner()
 	}
 }
 
@@ -1398,9 +1398,9 @@ impl PrivateRoute {
 	}
 }
 
-impl Into<RouteHint> for PrivateRoute {
-	fn into(self) -> RouteHint {
-		self.into_inner()
+impl From<PrivateRoute> for RouteHint {
+	fn from(val: PrivateRoute) -> Self {
+		val.into_inner()
 	}
 }
 
@@ -1766,7 +1766,7 @@ mod test {
 
 		// Multiple payment secrets
 		let invoice = {
-			let mut invoice = invoice_template.clone();
+			let mut invoice = invoice_template;
 			invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
 			invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
 			invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
@@ -1792,7 +1792,7 @@ mod test {
 		assert_eq!(invoice.hrp.raw_amount, Some(15));
 
 
-		let invoice = builder.clone()
+		let invoice = builder
 			.amount_milli_satoshis(150)
 			.build_raw()
 			.unwrap();
@@ -1846,7 +1846,7 @@ mod test {
 			.build_raw();
 		assert_eq!(long_route_res, Err(CreationError::RouteTooLong));
 
-		let sign_error_res = builder.clone()
+		let sign_error_res = builder
 			.description("Test".into())
 			.payment_secret(PaymentSecret([0; 32]))
 			.try_build_signed(|_| {
@@ -1876,7 +1876,7 @@ mod test {
 
 		let route_1 = RouteHint(vec![
 			RouteHintHop {
-				src_node_id: public_key.clone(),
+				src_node_id: public_key,
 				short_channel_id: de::parse_int_be(&[123; 8], 256).expect("short chan ID slice too big?"),
 				fees: RoutingFees {
 					base_msat: 2,
@@ -1887,7 +1887,7 @@ mod test {
 				htlc_maximum_msat: None,
 			},
 			RouteHintHop {
-				src_node_id: public_key.clone(),
+				src_node_id: public_key,
 				short_channel_id: de::parse_int_be(&[42; 8], 256).expect("short chan ID slice too big?"),
 				fees: RoutingFees {
 					base_msat: 3,
@@ -1901,7 +1901,7 @@ mod test {
 
 		let route_2 = RouteHint(vec![
 			RouteHintHop {
-				src_node_id: public_key.clone(),
+				src_node_id: public_key,
 				short_channel_id: 0,
 				fees: RoutingFees {
 					base_msat: 4,
@@ -1912,7 +1912,7 @@ mod test {
 				htlc_maximum_msat: None,
 			},
 			RouteHintHop {
-				src_node_id: public_key.clone(),
+				src_node_id: public_key,
 				short_channel_id: de::parse_int_be(&[1; 8], 256).expect("short chan ID slice too big?"),
 				fees: RoutingFees {
 					base_msat: 5,
@@ -1927,7 +1927,7 @@ mod test {
 		let builder = InvoiceBuilder::new(Currency::BitcoinTestnet)
 			.amount_milli_satoshis(123)
 			.duration_since_epoch(Duration::from_secs(1234567))
-			.payee_pub_key(public_key.clone())
+			.payee_pub_key(public_key)
 			.expiry_time(Duration::from_secs(54321))
 			.min_final_cltv_expiry_delta(144)
 			.fallback(Fallback::PubKeyHash([0;20]))

lightning-invoice/src/payment.rs

@@ -144,11 +144,11 @@ fn pay_invoice_using_amount<P: Deref>(
 	invoice: &Invoice, amount_msats: u64, payment_id: PaymentId, retry_strategy: Retry,
 	payer: P
 ) -> Result<(), PaymentError> where P::Target: Payer {
-	let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
-	let payment_secret = Some(invoice.payment_secret().clone());
+	let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
+	let payment_secret = Some(*invoice.payment_secret());
 	let mut payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key(),
 		invoice.min_final_cltv_expiry_delta() as u32)
-		.with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
+		.with_expiry_time(expiry_time_from_unix_epoch(invoice).as_secs())
 		.with_route_hints(invoice.route_hints());
 	if let Some(features) = invoice.features() {
 		payment_params = payment_params.with_features(features.clone());
@@ -203,7 +203,7 @@ where
 		payment_id: PaymentId, route_params: RouteParameters, retry_strategy: Retry
 	) -> Result<(), PaymentError> {
 		self.send_payment_with_retry(payment_hash, payment_secret, payment_id, route_params, retry_strategy)
-			.map_err(|e| PaymentError::Sending(e))
+			.map_err(PaymentError::Sending)
 	}
 }
 
@@ -344,7 +344,7 @@ mod tests {
 		let invoice = invoice(payment_preimage);
 		let amt_msat = 10_000;
 
-		match pay_zero_value_invoice(&invoice, amt_msat, Retry::Attempts(0), &nodes[0].node) {
+		match pay_zero_value_invoice(&invoice, amt_msat, Retry::Attempts(0), nodes[0].node) {
 			Err(PaymentError::Invoice("amount unexpected")) => {},
 			_ => panic!()
 		}