enable redundant_closure_for_method_calls lint

src/database/abstraction/rocksdb.rs

@@ -188,7 +188,7 @@ impl KvTree for RocksDbEngineTree<'_> {
             self.db
                 .rocks
                 .iterator_cf_opt(&self.cf(), readoptions, rocksdb::IteratorMode::Start)
-                .map(|r| r.unwrap())
+                .map(Result::unwrap)
                 .map(|(k, v)| (Vec::from(k), Vec::from(v))),
         )
     }
@@ -215,7 +215,7 @@ impl KvTree for RocksDbEngineTree<'_> {
                         },
                     ),
                 )
-                .map(|r| r.unwrap())
+                .map(Result::unwrap)
                 .map(|(k, v)| (Vec::from(k), Vec::from(v))),
         )
     }
@@ -269,7 +269,7 @@ impl KvTree for RocksDbEngineTree<'_> {
                     readoptions,
                     rocksdb::IteratorMode::From(&prefix, rocksdb::Direction::Forward),
                 )
-                .map(|r| r.unwrap())
+                .map(Result::unwrap)
                 .map(|(k, v)| (Vec::from(k), Vec::from(v)))
                 .take_while(move |(k, _)| k.starts_with(&prefix)),
         )

src/database/abstraction/sqlite.rs

@@ -194,7 +194,7 @@ impl SqliteTable {
             statement
                 .query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
                 .unwrap()
-                .map(move |r| r.unwrap()),
+                .map(Result::unwrap),
         );
 
         Box::new(PreparedStatementIterator {
@@ -291,7 +291,7 @@ impl KvTree for SqliteTable {
                 statement
                     .query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
                     .unwrap()
-                    .map(move |r| r.unwrap()),
+                    .map(Result::unwrap),
             );
             Box::new(PreparedStatementIterator {
                 iterator,
@@ -313,7 +313,7 @@ impl KvTree for SqliteTable {
                 statement
                     .query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
                     .unwrap()
-                    .map(move |r| r.unwrap()),
+                    .map(Result::unwrap),
             );
 
             Box::new(PreparedStatementIterator {

src/database/key_value/account_data.rs

@@ -20,7 +20,7 @@ impl service::account_data::Data for KeyValueDatabase {
         data: &serde_json::Value,
     ) -> Result<()> {
         let mut prefix = room_id
-            .map(|r| r.to_string())
+            .map(ToString::to_string)
             .unwrap_or_default()
             .as_bytes()
             .to_vec();
@@ -70,7 +70,7 @@ impl service::account_data::Data for KeyValueDatabase {
         kind: RoomAccountDataEventType,
     ) -> Result<Option<Box<serde_json::value::RawValue>>> {
         let mut key = room_id
-            .map(|r| r.to_string())
+            .map(ToString::to_string)
             .unwrap_or_default()
             .as_bytes()
             .to_vec();
@@ -105,7 +105,7 @@ impl service::account_data::Data for KeyValueDatabase {
         let mut userdata = HashMap::new();
 
         let mut prefix = room_id
-            .map(|r| r.to_string())
+            .map(ToString::to_string)
             .unwrap_or_default()
             .as_bytes()
             .to_vec();

src/database/key_value/appservice.rs

@@ -48,7 +48,7 @@ impl service::appservice::Data for KeyValueDatabase {
 
     fn all(&self) -> Result<Vec<(String, Registration)>> {
         self.iter_ids()?
-            .filter_map(|id| id.ok())
+            .filter_map(Result::ok)
             .map(move |id| {
                 Ok((
                     id.clone(),

src/database/key_value/globals.rs

@@ -56,7 +56,7 @@ impl service::globals::Data for KeyValueDatabase {
             .rooms
             .state_cache
             .rooms_joined(user_id)
-            .filter_map(|r| r.ok())
+            .filter_map(Result::ok)
         {
             let short_roomid = services()
                 .rooms

src/database/key_value/key_backups.rs

@@ -283,7 +283,7 @@ impl service::key_backups::Data for KeyValueDatabase {
 
                 Ok::<_, Error>((session_id, key_data))
             })
-            .filter_map(|r| r.ok())
+            .filter_map(Result::ok)
             .collect())
     }
 

src/database/key_value/rooms/state_cache.rs

@@ -101,7 +101,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         let mut joined_servers = HashSet::new();
         let mut real_users = HashSet::new();
 
-        for joined in self.room_members(room_id).filter_map(|r| r.ok()) {
+        for joined in self.room_members(room_id).filter_map(Result::ok) {
             joined_servers.insert(joined.server_name().to_owned());
             if joined.server_name() == services().globals.server_name()
                 && !services().users.is_deactivated(&joined).unwrap_or(true)
@@ -111,7 +111,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             joinedcount += 1;
         }
 
-        for _invited in self.room_members_invited(room_id).filter_map(|r| r.ok()) {
+        for _invited in self.room_members_invited(room_id).filter_map(Result::ok) {
             invitedcount += 1;
         }
 
@@ -126,7 +126,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             .unwrap()
             .insert(room_id.to_owned(), Arc::new(real_users));
 
-        for old_joined_server in self.room_servers(room_id).filter_map(|r| r.ok()) {
+        for old_joined_server in self.room_servers(room_id).filter_map(Result::ok) {
             if !joined_servers.remove(&old_joined_server) {
                 // Server not in room anymore
                 let mut roomserver_id = room_id.as_bytes().to_vec();

src/database/key_value/rooms/threads.rs

@@ -68,7 +68,7 @@ impl service::rooms::threads::Data for KeyValueDatabase {
                         })?)
                         .map_err(|_| Error::bad_database("Invalid UserId in threadid_userids."))
                     })
-                    .filter_map(|r| r.ok())
+                    .filter_map(Result::ok)
                     .collect(),
             ))
         } else {

src/database/key_value/rooms/user.rs

@@ -129,7 +129,7 @@ impl service::rooms::user::Data for KeyValueDatabase {
 
                     Ok::<_, Error>(room_id)
                 })
-                .filter_map(|r| r.ok())
+                .filter_map(Result::ok)
         });
 
         // We use the default compare function because keys are sorted correctly (not reversed)

src/database/key_value/transaction_ids.rs

@@ -12,7 +12,7 @@ impl service::transaction_ids::Data for KeyValueDatabase {
     ) -> Result<()> {
         let mut key = user_id.as_bytes().to_vec();
         key.push(0xff);
-        key.extend_from_slice(device_id.map(|d| d.as_bytes()).unwrap_or_default());
+        key.extend_from_slice(device_id.map(DeviceId::as_bytes).unwrap_or_default());
         key.push(0xff);
         key.extend_from_slice(txn_id.as_bytes());
 
@@ -29,7 +29,7 @@ impl service::transaction_ids::Data for KeyValueDatabase {
     ) -> Result<Option<Vec<u8>>> {
         let mut key = user_id.as_bytes().to_vec();
         key.push(0xff);
-        key.extend_from_slice(device_id.map(|d| d.as_bytes()).unwrap_or_default());
+        key.extend_from_slice(device_id.map(DeviceId::as_bytes).unwrap_or_default());
         key.push(0xff);
         key.extend_from_slice(txn_id.as_bytes());
 

src/database/key_value/uiaa.rs

@@ -34,7 +34,7 @@ impl service::uiaa::Data for KeyValueDatabase {
             .read()
             .unwrap()
             .get(&(user_id.to_owned(), device_id.to_owned(), session.to_owned()))
-            .map(|j| j.to_owned())
+            .map(ToOwned::to_owned)
     }
 
     fn update_uiaa_session(

src/database/key_value/users.rs

@@ -632,7 +632,7 @@ impl service::users::Data for KeyValueDatabase {
             .rooms
             .state_cache
             .rooms_joined(user_id)
-            .filter_map(|r| r.ok())
+            .filter_map(Result::ok)
         {
             // Don't send key updates to unencrypted rooms
             if services()
@@ -837,7 +837,7 @@ impl service::users::Data for KeyValueDatabase {
                         .map_err(|_| Error::bad_database("ToDeviceId has invalid count bytes."))?,
                 ))
             })
-            .filter_map(|r| r.ok())
+            .filter_map(Result::ok)
             .take_while(|&(_, count)| count <= until)
         {
             self.todeviceid_events.remove(&key)?;