From e4677bdb1e8a97f8d9eb887147437ce8c1f88cfa Mon Sep 17 00:00:00 2001
From: Min Kim <msk@dolbo.net>
Date: Wed, 3 Apr 2024 14:04:00 -0700
Subject: [PATCH] Simplify `SendError::MessageTooLarge`

This commit refactors the `SendError::MessageTooLarge` variant to no
longer carry the `std::num::TryFromIntError` as its inner error. This
change stems from the observation that the underlying `TryFromIntError`
did not provide additional useful context to the error handling
process.
---
 CHANGELOG.md   | 5 +++++
 src/frame.rs   | 8 ++++----
 src/message.rs | 2 +-
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 506de09..b5c7343 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,11 @@ Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Changed
+
+- `SendError::MessageTooLarge` no longer contains the underlying error,
+  `std::num::TryFromIntError`, since it does not provide any useful information.
+
 ### Removed
 
 - `RequestCode::Forward` and `message::send_forward_request`, since forwarding
diff --git a/src/frame.rs b/src/frame.rs
index b0510e5..9eef404 100644
--- a/src/frame.rs
+++ b/src/frame.rs
@@ -3,7 +3,7 @@
 use bincode::Options;
 use quinn::{RecvStream, SendStream};
 use serde::{Deserialize, Serialize};
-use std::{mem, num::TryFromIntError};
+use std::mem;
 use thiserror::Error;
 
 /// The error type for receiving and deserializing a frame.
@@ -60,7 +60,7 @@ pub enum SendError {
     #[error("failed serializing message")]
     SerializationFailure(#[from] bincode::Error),
     #[error("message is too large")]
-    MessageTooLarge(#[from] TryFromIntError),
+    MessageTooLarge,
     #[error("failed to write to a stream")]
     WriteError(#[from] quinn::WriteError),
 }
@@ -80,7 +80,7 @@ where
 {
     buf.resize(mem::size_of::<u32>(), 0);
     bincode::DefaultOptions::new().serialize_into(&mut *buf, &msg)?;
-    let len = u32::try_from(buf.len() - 4)?;
+    let len = u32::try_from(buf.len() - 4).map_err(|_| SendError::MessageTooLarge)?;
     buf[..mem::size_of::<u32>()].clone_from_slice(&len.to_be_bytes());
     send.write_all(buf).await?;
     buf.clear();
@@ -94,7 +94,7 @@ where
 /// * `SendError::MessageTooLarge`: if the message is too large
 /// * `SendError::WriteError`: if the message could not be written
 pub async fn send_raw(send: &mut SendStream, buf: &[u8]) -> Result<(), SendError> {
-    let len = u32::try_from(buf.len())?;
+    let len = u32::try_from(buf.len()).map_err(|_| SendError::MessageTooLarge)?;
     send.write_all(&len.to_be_bytes()).await?;
     send.write_all(buf).await?;
     Ok(())
diff --git a/src/message.rs b/src/message.rs
index 6294cdb..1eead6a 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -60,7 +60,7 @@ impl From<SendError> for HandshakeError {
     fn from(e: SendError) -> Self {
         match e {
             SendError::SerializationFailure(e) => HandshakeError::SerializationFailure(e),
-            SendError::MessageTooLarge(_) => HandshakeError::MessageTooLarge,
+            SendError::MessageTooLarge => HandshakeError::MessageTooLarge,
             SendError::WriteError(e) => HandshakeError::WriteError(e),
         }
     }