Use serde_json::Result alias

crates/ruma-appservice-api/src/event/push_events/v1.rs

@@ -60,7 +60,7 @@ impl IncomingRequest {
     pub fn try_into_sync_response(
         self,
         next_batch: impl Into<String>,
-    ) -> Result<ruma_client_api::r0::sync::sync_events::Response, serde_json::Error> {
+    ) -> serde_json::Result<ruma_client_api::r0::sync::sync_events::Response> {
         use ruma_client_api::r0::sync::sync_events;
         use ruma_identifiers::RoomId;
         use serde::Deserialize;

crates/ruma-client-api/src/r0/filter.rs

@@ -399,7 +399,7 @@ mod tests {
     };
 
     #[test]
-    fn default_filters_are_empty() -> Result<(), serde_json::Error> {
+    fn default_filters_are_empty() -> serde_json::Result<()> {
         assert_eq!(to_json_value(Filter::default())?, json!({}));
         assert_eq!(to_json_value(FilterDefinition::default())?, json!({}));
         assert_eq!(to_json_value(RoomEventFilter::default())?, json!({}));
@@ -409,7 +409,7 @@ mod tests {
     }
 
     #[test]
-    fn filter_definition_roundtrip() -> Result<(), serde_json::Error> {
+    fn filter_definition_roundtrip() -> serde_json::Result<()> {
         let filter = FilterDefinition::default();
         let filter_str = to_json_value(&filter)?;
 
@@ -420,7 +420,7 @@ mod tests {
     }
 
     #[test]
-    fn room_filter_definition_roundtrip() -> Result<(), serde_json::Error> {
+    fn room_filter_definition_roundtrip() -> serde_json::Result<()> {
         let filter = RoomFilter::default();
         let room_filter = to_json_value(&filter)?;
 
@@ -431,7 +431,7 @@ mod tests {
     }
 
     #[test]
-    fn issue_366() -> Result<(), serde_json::Error> {
+    fn issue_366() -> serde_json::Result<()> {
         let obj = json!({
             "lazy_load_members": true,
             "filter_json": { "contains_url": true, "types": ["m.room.message"] },

crates/ruma-events-macros/src/event_content.rs

@@ -243,7 +243,7 @@ pub fn expand_event_content(
 
             #[automatically_derived]
             impl #ruma_events::RedactedEventContent for #redacted_ident {
-                fn empty(ev_type: &str) -> Result<Self, #serde_json::Error> {
+                fn empty(ev_type: &str) -> #serde_json::Result<Self> {
                     if ev_type != #event_type {
                         return Err(#serde::de::Error::custom(
                             format!("expected event type `{}`, found `{}`", #event_type, ev_type)
@@ -346,7 +346,7 @@ fn generate_event_content_impl(
             fn from_parts(
                 ev_type: &str,
                 content: Box<#serde_json::value::RawValue>
-            ) -> Result<Self, #serde_json::Error> {
+            ) -> #serde_json::Result<Self> {
                 if ev_type != #event_type {
                     return Err(#serde::de::Error::custom(
                         format!("expected event type `{}`, found `{}`", #event_type, ev_type)

crates/ruma-events-macros/src/event_enum.rs

@@ -412,7 +412,7 @@ fn expand_content_enum(
             fn from_parts(
                 event_type: &::std::primitive::str,
                 input: ::std::boxed::Box<#serde_json::value::RawValue>,
-            ) -> ::std::result::Result<Self, #serde_json::Error> {
+            ) -> #serde_json::Result<Self> {
                 match event_type {
                     #(
                         #variant_attrs #event_type_str => {

crates/ruma-events/src/custom.rs

@@ -38,7 +38,7 @@ impl EventContent for CustomEventContent {
         &self.event_type
     }
 
-    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, serde_json::Error> {
+    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> serde_json::Result<Self> {
         let data = serde_json::from_str(content.get())?;
         Ok(Self { event_type: event_type.to_owned(), data })
     }
@@ -75,16 +75,13 @@ impl EventContent for RedactedCustomEventContent {
         &self.event_type
     }
 
-    fn from_parts(
+    fn from_parts(event_type: &str, _content: Box<RawJsonValue>) -> serde_json::Result<Self> {
-        event_type: &str,
-        _content: Box<RawJsonValue>,
-    ) -> Result<Self, serde_json::Error> {
         Ok(Self { event_type: event_type.to_owned() })
     }
 }
 
 impl RedactedEventContent for RedactedCustomEventContent {
-    fn empty(event_type: &str) -> Result<Self, serde_json::Error> {
+    fn empty(event_type: &str) -> serde_json::Result<Self> {
         Ok(Self { event_type: event_type.to_owned() })
     }
 

crates/ruma-events/src/lib.rs

@@ -253,7 +253,7 @@ pub trait EventContent: Sized + Serialize {
     fn event_type(&self) -> &str;
 
     /// Constructs the given event content.
-    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, serde_json::Error>;
+    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> serde_json::Result<Self>;
 }
 
 /// Trait to define the behavior of redacting an event.
@@ -285,11 +285,11 @@ pub trait RedactContent {
 /// Extension trait for Raw<EventContent>
 pub trait RawExt<T: EventContent> {
     /// Try to deserialize the JSON as an event's content.
-    fn deserialize_content(self, event_type: &str) -> Result<T, serde_json::Error>;
+    fn deserialize_content(self, event_type: &str) -> serde_json::Result<T>;
 }
 
 impl<T: EventContent> RawExt<T> for Raw<T> {
-    fn deserialize_content(self, event_type: &str) -> Result<T, serde_json::Error> {
+    fn deserialize_content(self, event_type: &str) -> serde_json::Result<T> {
         T::from_parts(event_type, self.into_json())
     }
 }
@@ -327,7 +327,7 @@ pub trait RedactedEventContent: EventContent {
     ///
     /// If called for anything but "empty" redacted content this will error.
     #[doc(hidden)]
-    fn empty(_event_type: &str) -> Result<Self, serde_json::Error> {
+    fn empty(_event_type: &str) -> serde_json::Result<Self> {
         Err(serde::de::Error::custom("this event is not redacted"))
     }
 

crates/ruma-events/src/room/aliases.rs

@@ -63,7 +63,7 @@ impl EventContent for RedactedAliasesEventContent {
         "m.room.aliases"
     }
 
-    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, serde_json::Error> {
+    fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> serde_json::Result<Self> {
         if event_type != "m.room.aliases" {
             return Err(::serde::de::Error::custom(format!(
                 "expected event type `m.room.aliases`, found `{}`",

crates/ruma-serde/src/raw.rs

@@ -133,7 +133,7 @@ where
     T: DeserializeOwned,
 {
     /// Try to deserialize the JSON as the expected type.
-    pub fn deserialize(&self) -> Result<T, serde_json::Error> {
+    pub fn deserialize(&self) -> serde_json::Result<T> {
         serde_json::from_str(self.json.get())
     }
 }

crates/ruma-serde/src/strings.rs

@@ -179,7 +179,7 @@ mod tests {
     use super::int_or_string_to_int;
 
     #[test]
-    fn int_or_string() -> Result<(), serde_json::Error> {
+    fn int_or_string() -> serde_json::Result<()> {
         #[derive(Debug, Deserialize)]
         struct Test {
             #[serde(deserialize_with = "int_or_string_to_int")]

crates/ruma-state-res/benches/state_res_bench.rs

@@ -606,14 +606,14 @@ pub mod event {
         pub fn from_id_value(
             id: EventId,
             json: serde_json::Value,
-        ) -> Result<Self, serde_json::Error> {
+        ) -> serde_json::Result<Self> {
             Ok(Self { event_id: id, rest: Pdu::RoomV3Pdu(serde_json::from_value(json)?) })
         }
 
         pub fn from_id_canon_obj(
             id: EventId,
             json: CanonicalJsonObject,
-        ) -> Result<Self, serde_json::Error> {
+        ) -> serde_json::Result<Self> {
             Ok(Self {
                 event_id: id,
                 // TODO: this is unfortunate (from_value(to_value(json)))...
@@ -648,7 +648,7 @@ pub mod event {
 
         pub fn deserialize_content<C: serde::de::DeserializeOwned>(
             &self,
-        ) -> Result<C, serde_json::Error> {
+        ) -> serde_json::Result<C> {
             match &self.rest {
                 Pdu::RoomV1Pdu(ev) => serde_json::from_value(ev.content.clone()),
                 Pdu::RoomV3Pdu(ev) => serde_json::from_value(ev.content.clone()),

crates/ruma-state-res/tests/utils.rs

@@ -567,14 +567,14 @@ pub mod event {
         pub fn from_id_value(
             id: EventId,
             json: serde_json::Value,
-        ) -> Result<Self, serde_json::Error> {
+        ) -> serde_json::Result<Self> {
             Ok(Self { event_id: id, rest: Pdu::RoomV3Pdu(serde_json::from_value(json)?) })
         }
 
         pub fn from_id_canon_obj(
             id: EventId,
             json: CanonicalJsonObject,
-        ) -> Result<Self, serde_json::Error> {
+        ) -> serde_json::Result<Self> {
             Ok(Self {
                 event_id: id,
                 // TODO: this is unfortunate (from_value(to_value(json)))...
@@ -611,7 +611,7 @@ pub mod event {
         }
         pub fn deserialize_content<C: serde::de::DeserializeOwned>(
             &self,
-        ) -> Result<C, serde_json::Error> {
+        ) -> serde_json::Result<C> {
             match &self.rest {
                 Pdu::RoomV1Pdu(ev) => serde_json::from_value(ev.content.clone()),
                 Pdu::RoomV3Pdu(ev) => serde_json::from_value(ev.content.clone()),