timeline: get rid of the indirection for the Unsupported* errors

No idea why we had these wrappers, and IMO they just add unnecessary
noise, so let's get rid of them.

Author: bnjbvr

crates/matrix-sdk-ui/src/timeline/error.rs

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::fmt;
-
 use matrix_sdk::{
     event_cache::{paginator::PaginatorError, EventCacheError},
     send_queue::RoomSendQueueError,
@@ -81,28 +79,8 @@ pub enum PaginationError {
     Paginator(#[source] PaginatorError),
 }
 
-#[derive(Error)]
-#[error("{0}")]
-pub struct UnsupportedReplyItem(UnsupportedReplyItemInner);
-
-impl UnsupportedReplyItem {
-    pub(super) const MISSING_EVENT_ID: Self = Self(UnsupportedReplyItemInner::MissingEventId);
-    pub(super) const MISSING_JSON: Self = Self(UnsupportedReplyItemInner::MissingJson);
-    pub(super) const MISSING_EVENT: Self = Self(UnsupportedReplyItemInner::MissingEvent);
-    pub(super) const FAILED_TO_DESERIALIZE_EVENT: Self =
-        Self(UnsupportedReplyItemInner::FailedToDeserializeEvent);
-    pub(super) const STATE_EVENT: Self = Self(UnsupportedReplyItemInner::StateEvent);
-}
-
-#[cfg(not(tarpaulin_include))]
-impl fmt::Debug for UnsupportedReplyItem {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
 #[derive(Debug, Error)]
-enum UnsupportedReplyItemInner {
+pub enum UnsupportedReplyItem {
     #[error("local messages whose event ID is not known can't be replied to currently")]
     MissingEventId,
     #[error("redacted events whose JSON form isn't available can't be replied")]
@@ -115,29 +93,8 @@ enum UnsupportedReplyItemInner {
     StateEvent,
 }
 
-#[derive(Error)]
-#[error("{0}")]
-pub struct UnsupportedEditItem(UnsupportedEditItemInner);
-
-impl UnsupportedEditItem {
-    pub(super) const MISSING_EVENT_ID: Self = Self(UnsupportedEditItemInner::MissingEventId);
-    pub(super) const NOT_ROOM_MESSAGE: Self = Self(UnsupportedEditItemInner::NotRoomMessage);
-    pub(super) const NOT_POLL_EVENT: Self = Self(UnsupportedEditItemInner::NotPollEvent);
-    pub(super) const NOT_OWN_EVENT: Self = Self(UnsupportedEditItemInner::NotOwnEvent);
-    pub(super) const MISSING_EVENT: Self = Self(UnsupportedEditItemInner::MissingEvent);
-    pub(super) const FAILED_TO_DESERIALIZE_EVENT: Self =
-        Self(UnsupportedEditItemInner::FailedToDeserializeEvent);
-}
-
-#[cfg(not(tarpaulin_include))]
-impl fmt::Debug for UnsupportedEditItem {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
 #[derive(Debug, Error)]
-enum UnsupportedEditItemInner {
+pub enum UnsupportedEditItem {
     #[error("local messages whose event ID is not known can't be edited currently")]
     MissingEventId,
     #[error("tried to edit a non-message event")]

crates/matrix-sdk-ui/src/timeline/event_item/mod.rs

@@ -429,15 +429,15 @@ impl EventTimelineItem {
             TimelineItemContent::Message(msg) => ReplyContent::Message(msg.to_owned()),
             _ => {
                 let Some(raw_event) = self.latest_json() else {
-                    return Err(UnsupportedReplyItem::MISSING_JSON);
+                    return Err(UnsupportedReplyItem::MissingJson);
                 };
 
                 ReplyContent::Raw(raw_event.clone())
             }
         };
 
         let Some(event_id) = self.event_id() else {
-            return Err(UnsupportedReplyItem::MISSING_EVENT_ID);
+            return Err(UnsupportedReplyItem::MissingEventId);
         };
 
         Ok(RepliedToInfo {
@@ -451,15 +451,15 @@ impl EventTimelineItem {
     /// Gives the information needed to edit the event of the item.
     pub fn edit_info(&self) -> Result<EditInfo, UnsupportedEditItem> {
         if !self.is_own() {
-            return Err(UnsupportedEditItem::NOT_OWN_EVENT);
+            return Err(UnsupportedEditItem::NotOwnEvent);
         }
         // Early returns here must be in sync with
         // `EventTimelineItem::can_be_edited`
         let Some(event_id) = self.event_id() else {
-            return Err(UnsupportedEditItem::MISSING_EVENT_ID);
+            return Err(UnsupportedEditItem::MissingEventId);
         };
         let TimelineItemContent::Message(original_content) = self.content() else {
-            return Err(UnsupportedEditItem::NOT_ROOM_MESSAGE);
+            return Err(UnsupportedEditItem::NotRoomMessage);
         };
         Ok(EditInfo { event_id: event_id.to_owned(), original_message: original_content.clone() })
     }

crates/matrix-sdk-ui/src/timeline/mod.rs

@@ -414,7 +414,7 @@ impl Timeline {
 
         let event = self.room().event(event_id).await.map_err(|error| {
             error!("Failed to fetch event with ID {event_id} with error: {error}");
-            UnsupportedReplyItem::MISSING_EVENT
+            UnsupportedReplyItem::MissingEvent
         })?;
 
         // We need to get the content and we can do that by casting the event as a
@@ -424,7 +424,7 @@ impl Timeline {
         let raw_sync_event: Raw<AnySyncTimelineEvent> = event.event.cast();
         let sync_event = raw_sync_event.deserialize().map_err(|error| {
             error!("Failed to deserialize event with ID {event_id} with error: {error}");
-            UnsupportedReplyItem::FAILED_TO_DESERIALIZE_EVENT
+            UnsupportedReplyItem::FailedToDeserializeEvent
         })?;
 
         let reply_content = match &sync_event {
@@ -442,7 +442,7 @@ impl Timeline {
                     ReplyContent::Raw(raw_sync_event)
                 }
             }
-            AnySyncTimelineEvent::State(_) => return Err(UnsupportedReplyItem::STATE_EVENT),
+            AnySyncTimelineEvent::State(_) => return Err(UnsupportedReplyItem::StateEvent),
         };
 
         Ok(RepliedToInfo {
@@ -514,7 +514,7 @@ impl Timeline {
 
         let event = self.room().event(event_id).await.map_err(|error| {
             error!("Failed to fetch event with ID {event_id} with error: {error}");
-            UnsupportedEditItem::MISSING_EVENT
+            UnsupportedEditItem::MissingEvent
         })?;
 
         // We need to get the content and we can do that by casting
@@ -524,11 +524,11 @@ impl Timeline {
         let raw_sync_event: Raw<AnySyncTimelineEvent> = event.event.cast();
         let event = raw_sync_event.deserialize().map_err(|error| {
             error!("Failed to deserialize event with ID {event_id} with error: {error}");
-            UnsupportedEditItem::FAILED_TO_DESERIALIZE_EVENT
+            UnsupportedEditItem::FailedToDeserializeEvent
         })?;
 
         if event.sender() != self.room().own_user_id() {
-            return Err(UnsupportedEditItem::NOT_OWN_EVENT);
+            return Err(UnsupportedEditItem::NotOwnEvent);
         };
 
         if let AnySyncTimelineEvent::MessageLike(message_like_event) = &event {
@@ -545,7 +545,7 @@ impl Timeline {
             }
         }
 
-        Err(UnsupportedEditItem::NOT_ROOM_MESSAGE)
+        Err(UnsupportedEditItem::NotRoomMessage)
     }
 
     pub async fn edit_poll(
@@ -559,14 +559,14 @@ impl Timeline {
 
         // Early returns here must be in sync with `EventTimelineItem::is_editable`.
         if !edit_item.is_own() {
-            return Err(UnsupportedEditItem::NOT_OWN_EVENT.into());
+            return Err(UnsupportedEditItem::NotOwnEvent.into());
         }
         let Some(event_id) = edit_item.event_id() else {
-            return Err(UnsupportedEditItem::MISSING_EVENT_ID.into());
+            return Err(UnsupportedEditItem::MissingEvent.into());
         };
 
         let TimelineItemContent::Poll(_) = edit_item.content() else {
-            return Err(UnsupportedEditItem::NOT_POLL_EVENT.into());
+            return Err(UnsupportedEditItem::NotPollEvent.into());
         };
 
         let content = ReplacementUnstablePollStartEventContent::plain_text(