enable map_unwrap_or lint

Cargo.toml

@@ -46,6 +46,7 @@ let_underscore_must_use = "warn"
 lossy_float_literal = "warn"
 manual_let_else = "warn"
 manual_string_new = "warn"
+map_unwrap_or = "warn"
 mem_forget = "warn"
 missing_assert_message = "warn"
 mod_module_files = "warn"

src/api/client_server/context.rs

@@ -105,8 +105,7 @@ pub(crate) async fn get_context_route(
 
     let start_token = events_before
         .last()
-        .map(|(count, _)| count.stringify())
+        .map_or_else(|| base_token.stringify(), |(count, _)| count.stringify());
-        .unwrap_or_else(|| base_token.stringify());
 
     let events_before: Vec<_> = events_before
         .into_iter()
@@ -161,8 +160,7 @@ pub(crate) async fn get_context_route(
 
     let end_token = events_after
         .last()
-        .map(|(count, _)| count.stringify())
+        .map_or_else(|| base_token.stringify(), |(count, _)| count.stringify());
-        .unwrap_or_else(|| base_token.stringify());
 
     let events_after: Vec<_> = events_after
         .into_iter()

src/api/client_server/tag.rs

@@ -24,18 +24,19 @@ pub(crate) async fn update_tag_route(
         RoomAccountDataEventType::Tag,
     )?;
 
-    let mut tags_event = event
+    let mut tags_event = event.map_or_else(
-        .map(|e| {
+        || {
-            serde_json::from_str(e.get())
-                .map_err(|_| Error::bad_database("Invalid account data event in db."))
-        })
-        .unwrap_or_else(|| {
             Ok(TagEvent {
                 content: TagEventContent {
                     tags: BTreeMap::new(),
                 },
             })
-        })?;
+        },
+        |e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        },
+    )?;
 
     tags_event
         .content
@@ -68,18 +69,19 @@ pub(crate) async fn delete_tag_route(
         RoomAccountDataEventType::Tag,
     )?;
 
-    let mut tags_event = event
+    let mut tags_event = event.map_or_else(
-        .map(|e| {
+        || {
-            serde_json::from_str(e.get())
-                .map_err(|_| Error::bad_database("Invalid account data event in db."))
-        })
-        .unwrap_or_else(|| {
             Ok(TagEvent {
                 content: TagEventContent {
                     tags: BTreeMap::new(),
                 },
             })
-        })?;
+        },
+        |e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        },
+    )?;
 
     tags_event.content.tags.remove(&body.tag.clone().into());
 
@@ -109,18 +111,19 @@ pub(crate) async fn get_tags_route(
         RoomAccountDataEventType::Tag,
     )?;
 
-    let tags_event = event
+    let tags_event = event.map_or_else(
-        .map(|e| {
+        || {
-            serde_json::from_str(e.get())
-                .map_err(|_| Error::bad_database("Invalid account data event in db."))
-        })
-        .unwrap_or_else(|| {
             Ok(TagEvent {
                 content: TagEventContent {
                     tags: BTreeMap::new(),
                 },
             })
-        })?;
+        },
+        |e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        },
+    )?;
 
     Ok(get_tags::v3::Response {
         tags: tags_event.content.tags,

src/database/key_value/globals.rs

@@ -276,7 +276,7 @@ lasttimelinecount_cache: {lasttimelinecount_cache}\n"
                 );
                 tree
             })
-            .unwrap_or_else(BTreeMap::new);
+            .unwrap_or_default();
 
         Ok(signingkeys)
     }

src/database/key_value/rooms/user.rs

@@ -31,11 +31,10 @@ impl service::rooms::user::Data for KeyValueDatabase {
 
         self.userroomid_notificationcount
             .get(&userroom_id)?
-            .map(|bytes| {
+            .map_or(Ok(0), |bytes| {
                 utils::u64_from_bytes(&bytes)
                     .map_err(|_| Error::bad_database("Invalid notification count in db."))
             })
-            .unwrap_or(Ok(0))
     }
 
     fn highlight_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
@@ -45,11 +44,10 @@ impl service::rooms::user::Data for KeyValueDatabase {
 
         self.userroomid_highlightcount
             .get(&userroom_id)?
-            .map(|bytes| {
+            .map_or(Ok(0), |bytes| {
                 utils::u64_from_bytes(&bytes)
                     .map_err(|_| Error::bad_database("Invalid highlight count in db."))
             })
-            .unwrap_or(Ok(0))
     }
 
     fn last_notification_read(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {

src/database/key_value/users.rs

@@ -348,12 +348,11 @@ impl service::users::Data for KeyValueDatabase {
     fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
         self.userid_lastonetimekeyupdate
             .get(user_id.as_bytes())?
-            .map(|bytes| {
+            .map_or(Ok(0), |bytes| {
                 utils::u64_from_bytes(&bytes).map_err(|_| {
                     Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.")
                 })
             })
-            .unwrap_or(Ok(0))
     }
 
     fn take_one_time_key(

src/service/rooms/state_accessor.rs

@@ -363,41 +363,46 @@ impl Service {
         federation: bool,
     ) -> Result<bool> {
         self.room_state_get(room_id, &StateEventType::RoomPowerLevels, "")?
-            .map(|e| {
+            .map_or_else(
-                serde_json::from_str(e.content.get())
+                // Falling back on m.room.create to judge power levels
-                    .map(|c: RoomPowerLevelsEventContent| c.into())
+                || {
-                    .map(|e: RoomPowerLevels| {
+                    if let Some(pdu) =
-                        e.user_can_redact_event_of_other(sender)
+                        self.room_state_get(room_id, &StateEventType::RoomCreate, "")?
-                            || e.user_can_redact_own_event(sender)
+                    {
-                                && if let Ok(Some(pdu)) = services().rooms.timeline.get_pdu(redacts)
+                        Ok(pdu.sender == sender
-                                {
+                            || if let Ok(Some(pdu)) = services().rooms.timeline.get_pdu(redacts) {
-                                    if federation {
+                                pdu.sender == sender
-                                        pdu.sender().server_name() == sender.server_name()
+                            } else {
+                                false
+                            })
+                    } else {
+                        Err(Error::bad_database(
+                            "No m.room.power_levels or m.room.create events in database for room",
+                        ))
+                    }
+                },
+                |e| {
+                    serde_json::from_str(e.content.get())
+                        .map(|c: RoomPowerLevelsEventContent| c.into())
+                        .map(|e: RoomPowerLevels| {
+                            e.user_can_redact_event_of_other(sender)
+                                || e.user_can_redact_own_event(sender)
+                                    && if let Ok(Some(pdu)) =
+                                        services().rooms.timeline.get_pdu(redacts)
+                                    {
+                                        if federation {
+                                            pdu.sender().server_name() == sender.server_name()
+                                        } else {
+                                            pdu.sender == sender
+                                        }
                                     } else {
-                                        pdu.sender == sender
+                                        false
                                     }
-                                } else {
-                                    false
-                                }
-                    })
-                    .map_err(|_| {
-                        Error::bad_database("Invalid m.room.power_levels event in database")
-                    })
-            })
-            // Falling back on m.room.create to judge power levels
-            .unwrap_or_else(|| {
-                if let Some(pdu) = self.room_state_get(room_id, &StateEventType::RoomCreate, "")? {
-                    Ok(pdu.sender == sender
-                        || if let Ok(Some(pdu)) = services().rooms.timeline.get_pdu(redacts) {
-                            pdu.sender == sender
-                        } else {
-                            false
                         })
-                } else {
+                        .map_err(|_| {
-                    Err(Error::bad_database(
+                            Error::bad_database("Invalid m.room.power_levels event in database")
-                        "No m.room.power_levels or m.room.create events in database for room",
+                        })
-                    ))
+                },
-                }
+            )
-            })
     }
 }

src/service/rooms/timeline.rs

@@ -338,8 +338,10 @@ impl Service {
                         .map_err(|_| Error::bad_database("Invalid push rules event in db."))
                 })
                 .transpose()?
-                .map(|ev: PushRulesEvent| ev.content.global)
+                .map_or_else(
-                .unwrap_or_else(|| Ruleset::server_default(user));
+                    || Ruleset::server_default(user),
+                    |ev: PushRulesEvent| ev.content.global,
+                );
 
             let mut highlight = false;
             let mut notify = false;

src/service/sending.rs

@@ -581,8 +581,10 @@ impl Service {
                         )
                         .unwrap_or_default()
                         .and_then(|event| serde_json::from_str::<PushRulesEvent>(event.get()).ok())
-                        .map(|ev: PushRulesEvent| ev.content.global)
+                        .map_or_else(
-                        .unwrap_or_else(|| push::Ruleset::server_default(userid));
+                            || push::Ruleset::server_default(userid),
+                            |ev: PushRulesEvent| ev.content.global,
+                        );
 
                     let unread: UInt = services()
                         .rooms

src/service/uiaa.rs

@@ -47,10 +47,10 @@ impl Service {
         auth: &AuthData,
         uiaainfo: &UiaaInfo,
     ) -> Result<(bool, UiaaInfo)> {
-        let mut uiaainfo = auth
+        let mut uiaainfo = auth.session().map_or_else(
-            .session()
+            || Ok(uiaainfo.clone()),
-            .map(|session| self.db.get_uiaa_session(user_id, device_id, session))
+            |session| self.db.get_uiaa_session(user_id, device_id, session),
-            .unwrap_or_else(|| Ok(uiaainfo.clone()))?;
+        )?;
 
         if uiaainfo.session.is_none() {
             uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));