ln/refactor: rename HTLCFailReasonRepr to HTLCFailure

This type is only used internally in onion_utils, so we can rename it
to HTLCFailure to be more concise.

Author: carlaKC

lightning/src/ln/onion_utils.rs

@@ -1765,8 +1765,8 @@ impl_writeable_tlv_based_enum!(LocalHTLCFailureReason,
 impl From<&HTLCFailurePayload> for HTLCHandlingFailureReason {
 	fn from(value: &HTLCFailurePayload) -> Self {
 		match value.0 {
-			HTLCFailReasonRepr::LightningError { .. } => HTLCHandlingFailureReason::Downstream,
-			HTLCFailReasonRepr::Reason { failure_reason, .. } => {
+			HTLCFailure::LightningError { .. } => HTLCHandlingFailureReason::Downstream,
+			HTLCFailure::Reason { failure_reason, .. } => {
 				HTLCHandlingFailureReason::Local { reason: failure_reason }
 			},
 		}
@@ -1776,19 +1776,21 @@ impl From<&HTLCFailurePayload> for HTLCHandlingFailureReason {
 /// Contains the information required to construct the failure message for a failed HTLC.
 #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug
 #[cfg_attr(test, derive(PartialEq))]
-pub(super) struct HTLCFailurePayload(HTLCFailReasonRepr);
+pub(super) struct HTLCFailurePayload(HTLCFailure);
 
 #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug
 #[cfg_attr(test, derive(PartialEq))]
-enum HTLCFailReasonRepr {
+enum HTLCFailure {
+	/// HTLC failed downstream and should be failed back with the encrypted error packet.
 	LightningError { err: msgs::OnionErrorPacket, hold_time: Option<u32> },
+	/// HTLC failed locally and should be failed back with the payload provided.
 	Reason { data: Vec<u8>, failure_reason: LocalHTLCFailureReason },
 }
 
 impl HTLCFailurePayload {
 	pub fn set_hold_time(&mut self, hold_time: u32) {
 		match self.0 {
-			HTLCFailReasonRepr::LightningError { hold_time: ref mut current_hold_time, .. } => {
+			HTLCFailure::LightningError { hold_time: ref mut current_hold_time, .. } => {
 				*current_hold_time = Some(hold_time);
 			},
 			_ => {},
@@ -1799,15 +1801,15 @@ impl HTLCFailurePayload {
 impl core::fmt::Debug for HTLCFailurePayload {
 	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
 		match self.0 {
-			HTLCFailReasonRepr::Reason { ref failure_reason, .. } => {
+			HTLCFailure::Reason { ref failure_reason, .. } => {
 				write!(
 					f,
 					"HTLC failure {:?} error code {}",
 					failure_reason,
 					failure_reason.failure_code()
 				)
 			},
-			HTLCFailReasonRepr::LightningError { .. } => {
+			HTLCFailure::LightningError { .. } => {
 				write!(f, "pre-built LightningError")
 			},
 		}
@@ -1825,17 +1827,17 @@ impl Readable for HTLCFailurePayload {
 	}
 }
 
-impl_writeable_tlv_based_enum!(HTLCFailReasonRepr,
+impl_writeable_tlv_based_enum!(HTLCFailure,
 	(0, LightningError) => {
 		(0, data, (legacy, Vec<u8>, |us|
-			if let &HTLCFailReasonRepr::LightningError { err: msgs::OnionErrorPacket { ref data, .. }, .. } = us {
+			if let &HTLCFailure::LightningError { err: msgs::OnionErrorPacket { ref data, .. }, .. } = us {
 				Some(data)
 			} else {
 				None
 			})
 		),
 		(1, attribution_data, (legacy, AttributionData, |us|
-			if let &HTLCFailReasonRepr::LightningError { err: msgs::OnionErrorPacket { ref attribution_data, .. }, .. } = us {
+			if let &HTLCFailure::LightningError { err: msgs::OnionErrorPacket { ref attribution_data, .. }, .. } = us {
 				attribution_data.as_ref()
 			} else {
 				None
@@ -1846,9 +1848,9 @@ impl_writeable_tlv_based_enum!(HTLCFailReasonRepr,
 	},
 	(1, Reason) => {
 		(0, _failure_code, (legacy, u16,
-			|r: &HTLCFailReasonRepr| match r {
-				HTLCFailReasonRepr::LightningError{ .. } => None,
-				HTLCFailReasonRepr::Reason{ failure_reason, .. } => Some(failure_reason.failure_code())
+			|r: &HTLCFailure| match r {
+				HTLCFailure::LightningError{ .. } => None,
+				HTLCFailure::Reason{ failure_reason, .. } => Some(failure_reason.failure_code())
 			})),
 		// failure_code was required, and is replaced by reason in 0.2 so any time we do not have a
 		// reason available failure_code will be Some and can be expressed as a reason.
@@ -1930,15 +1932,15 @@ impl HTLCFailurePayload {
 			},
 		}
 
-		Self(HTLCFailReasonRepr::Reason { data, failure_reason })
+		Self(HTLCFailure::Reason { data, failure_reason })
 	}
 
 	pub(super) fn from_failure_code(failure_reason: LocalHTLCFailureReason) -> Self {
 		Self::reason(failure_reason, Vec::new())
 	}
 
 	pub(super) fn from_msg(msg: &msgs::UpdateFailHTLC) -> Self {
-		Self(HTLCFailReasonRepr::LightningError {
+		Self(HTLCFailure::LightningError {
 			err: OnionErrorPacket {
 				data: msg.reason.clone(),
 				attribution_data: msg.attribution_data.clone(),
@@ -1956,7 +1958,7 @@ impl HTLCFailurePayload {
 		&self, incoming_packet_shared_secret: &[u8; 32], secondary_shared_secret: &Option<[u8; 32]>,
 	) -> msgs::OnionErrorPacket {
 		match self.0 {
-			HTLCFailReasonRepr::Reason { ref data, ref failure_reason } => {
+			HTLCFailure::Reason { ref data, ref failure_reason } => {
 				// Final hop always reports zero hold time.
 				let hold_time: u32 = 0;
 
@@ -1982,7 +1984,7 @@ impl HTLCFailurePayload {
 					)
 				}
 			},
-			HTLCFailReasonRepr::LightningError { ref err, hold_time } => {
+			HTLCFailure::LightningError { ref err, hold_time } => {
 				let mut err = err.clone();
 				let hold_time = hold_time.unwrap_or(0);
 
@@ -2001,11 +2003,11 @@ impl HTLCFailurePayload {
 		L::Target: Logger,
 	{
 		match self.0 {
-			HTLCFailReasonRepr::LightningError { ref err, .. } => {
+			HTLCFailure::LightningError { ref err, .. } => {
 				process_onion_failure(secp_ctx, logger, &htlc_source, err.clone())
 			},
 			#[allow(unused)]
-			HTLCFailReasonRepr::Reason { ref data, ref failure_reason } => {
+			HTLCFailure::Reason { ref data, ref failure_reason } => {
 				// we get a fail_malformed_htlc from the first hop
 				// TODO: We'd like to generate a NetworkUpdate for temporary
 				// failures here, but that would be insufficient as find_route