fix(search): make the experimental-search feature compile

And simplify the code for parsing in the event cache.

Author: bnjbvr

crates/matrix-sdk-common/src/deserialized_responses.rs

@@ -762,6 +762,11 @@ impl TimelineEventKind {
         self.raw().get_field::<OwnedEventId>("event_id").ok().flatten()
     }
 
+    /// Whether we could not decrypt the event (i.e. it is a UTD).
+    pub fn is_utd(&self) -> bool {
+        matches!(self, TimelineEventKind::UnableToDecrypt { .. })
+    }
+
     /// If the event was a decrypted event that was successfully decrypted, get
     /// its encryption info. Otherwise, `None`.
     pub fn encryption_info(&self) -> Option<&Arc<EncryptionInfo>> {

crates/matrix-sdk/src/event_cache/room/mod.rs

@@ -640,8 +640,6 @@ mod private {
         sync::Timeline,
     };
     use matrix_sdk_common::executor::spawn;
-    #[cfg(feature = "experimental-search")]
-    use ruma::events::AnyMessageLikeEvent;
     use ruma::{
         events::{
             relation::RelationType, room::redaction::SyncRoomRedactionEvent,
@@ -1464,28 +1462,20 @@ mod private {
 
         #[cfg(feature = "experimental-search")]
         fn parse_timeline_event(&self, event: &TimelineEvent) -> Option<AnySyncMessageLikeEvent> {
-            let maybe_try_event = match &event.kind {
-                TimelineEventKind::Decrypted(d) => {
-                    Some(d.event.deserialize().map(AnyMessageLikeEvent::into))
-                }
-                TimelineEventKind::PlainText { event } => match event.deserialize() {
-                    Ok(event_obj) => match event_obj {
-                        AnySyncTimelineEvent::MessageLike(sync_event) => Some(Ok(sync_event)),
-                        AnySyncTimelineEvent::State(_) => None,
-                    },
-                    Err(e) => Some(Err(e)),
-                },
+            if event.kind.is_utd() {
+                return None;
+            }
 
-                TimelineEventKind::UnableToDecrypt { event: _, utd_info: _ } => None,
-            };
+            match event.raw().deserialize() {
+                Ok(event) => match event {
+                    AnySyncTimelineEvent::MessageLike(event) => Some(event),
+                    AnySyncTimelineEvent::State(_) => None,
+                },
 
-            match maybe_try_event {
-                Some(Ok(event)) => Some(event),
-                Some(Err(e)) => {
+                Err(e) => {
                     warn!("failed to parse event: {e:?}");
                     None
                 }
-                None => None,
             }
         }