resolve couple pedantic clippy lints, remove unnecessary qualifications

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/database/abstraction/rocksdb.rs

@@ -264,7 +264,7 @@ fn backup(&self) -> Result<(), Box<dyn std::error::Error>> {
 		if self.config.database_backups_to_keep >= 0 {
 			let keep = u32::try_from(self.config.database_backups_to_keep)?;
 			if let Err(e) = engine.purge_old_backups(keep.try_into()?) {
-				error!("Failed to purge old backup: {:?}", e.to_string())
+				error!("Failed to purge old backup: {:?}", e.to_string());
 			}
 		}
 
@@ -398,7 +398,7 @@ fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
 			self.db
 				.rocks
 				.iterator_cf_opt(&self.cf(), readoptions, rust_rocksdb::IteratorMode::Start)
-				.map(std::result::Result::unwrap)
+				.map(Result::unwrap)
 				.map(|(k, v)| (Vec::from(k), Vec::from(v))),
 		)
 	}
@@ -422,7 +422,7 @@ fn iter_from<'a>(&'a self, from: &[u8], backwards: bool) -> Box<dyn Iterator<Ite
 						},
 					),
 				)
-				.map(std::result::Result::unwrap)
+				.map(Result::unwrap)
 				.map(|(k, v)| (Vec::from(k), Vec::from(v))),
 		)
 	}
@@ -485,7 +485,7 @@ fn scan_prefix<'a>(&'a self, prefix: Vec<u8>) -> Box<dyn Iterator<Item = (Vec<u8
 					readoptions,
 					rust_rocksdb::IteratorMode::From(&prefix, rust_rocksdb::Direction::Forward),
 				)
-				.map(std::result::Result::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

@@ -161,10 +161,7 @@ pub fn iter_with_guard<'a>(&'a self, guard: &'a Connection) -> Box<dyn Iterator<
 		//let name = self.name.clone();
 
 		let iterator = Box::new(
-			statement
-				.query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
-				.unwrap()
-				.map(std::result::Result::unwrap),
+			statement.query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1)))).unwrap().map(Result::unwrap),
 		);
 
 		Box::new(PreparedStatementIterator {
@@ -251,7 +248,7 @@ fn iter_from<'a>(&'a self, from: &[u8], backwards: bool) -> Box<dyn Iterator<Ite
 				statement
 					.query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
 					.unwrap()
-					.map(std::result::Result::unwrap),
+					.map(Result::unwrap),
 			);
 			Box::new(PreparedStatementIterator {
 				iterator,
@@ -273,7 +270,7 @@ fn iter_from<'a>(&'a self, from: &[u8], backwards: bool) -> Box<dyn Iterator<Ite
 				statement
 					.query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
 					.unwrap()
-					.map(std::result::Result::unwrap),
+					.map(Result::unwrap),
 			);
 
 			Box::new(PreparedStatementIterator {

src/database/key_value/appservice.rs

@@ -40,7 +40,7 @@ fn iter_ids<'a>(&'a self) -> Result<Box<dyn Iterator<Item = Result<String>> + 'a
 
 	fn all(&self) -> Result<Vec<(String, Registration)>> {
 		self.iter_ids()?
-			.filter_map(std::result::Result::ok)
+			.filter_map(Result::ok)
 			.map(move |id| {
 				Ok((
 					id.clone(),

src/database/key_value/key_backups.rs

@@ -222,7 +222,7 @@ fn get_room(
 
 				Ok::<_, Error>((session_id, key_data))
 			})
-			.filter_map(std::result::Result::ok)
+			.filter_map(Result::ok)
 			.collect())
 	}
 

src/database/key_value/rooms/state_cache.rs

@@ -95,7 +95,7 @@ fn update_joined_count(&self, room_id: &RoomId) -> Result<()> {
 		let mut joined_servers = HashSet::new();
 		let mut real_users = HashSet::new();
 
-		for joined in self.room_members(room_id).filter_map(std::result::Result::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)
@@ -105,7 +105,7 @@ fn update_joined_count(&self, room_id: &RoomId) -> Result<()> {
 			joinedcount += 1;
 		}
 
-		for _invited in self.room_members_invited(room_id).filter_map(std::result::Result::ok) {
+		for _invited in self.room_members_invited(room_id).filter_map(Result::ok) {
 			invitedcount += 1;
 		}
 
@@ -115,7 +115,7 @@ fn update_joined_count(&self, room_id: &RoomId) -> Result<()> {
 
 		self.our_real_users_cache.write().unwrap().insert(room_id.to_owned(), Arc::new(real_users));
 
-		for old_joined_server in self.room_servers(room_id).filter_map(std::result::Result::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

@@ -54,7 +54,7 @@ fn get_participants(&self, root_id: &[u8]) -> Result<Option<Vec<OwnedUserId>>> {
 						)
 						.map_err(|_| Error::bad_database("Invalid UserId in threadid_userids."))
 					})
-					.filter_map(std::result::Result::ok)
+					.filter_map(Result::ok)
 					.collect(),
 			))
 		} else {

src/database/key_value/rooms/user.rs

@@ -106,7 +106,7 @@ fn get_shared_rooms<'a>(
 
 					Ok::<_, Error>(room_id)
 				})
-				.filter_map(std::result::Result::ok)
+				.filter_map(Result::ok)
 		});
 
 		// We use the default compare function because keys are sorted correctly (not

src/database/key_value/users.rs

@@ -562,7 +562,7 @@ fn keys_changed<'a>(
 
 	fn mark_device_key_update(&self, user_id: &UserId) -> Result<()> {
 		let count = services().globals.next_count()?.to_be_bytes();
-		for room_id in services().rooms.state_cache.rooms_joined(user_id).filter_map(std::result::Result::ok) {
+		for room_id in services().rooms.state_cache.rooms_joined(user_id).filter_map(Result::ok) {
 			// Don't send key updates to unencrypted rooms
 			if services().rooms.state_accessor.room_state_get(&room_id, &StateEventType::RoomEncryption, "")?.is_none()
 			{
@@ -719,7 +719,7 @@ fn remove_to_device_events(&self, user_id: &UserId, device_id: &DeviceId, until:
 						.map_err(|_| Error::bad_database("ToDeviceId has invalid count bytes."))?,
 				))
 			})
-			.filter_map(std::result::Result::ok)
+			.filter_map(Result::ok)
 			.take_while(|&(_, count)| count <= until)
 		{
 			self.todeviceid_events.remove(&key)?;

src/database/mod.rs

@@ -431,12 +431,9 @@ pub async fn load_or_create(config: Config) -> Result<()> {
 				for (roomserverid, _) in db.roomserverids.iter() {
 					let mut parts = roomserverid.split(|&b| b == 0xFF);
 					let room_id = parts.next().expect("split always returns one element");
-					let servername = match parts.next() {
-						Some(s) => s,
-						None => {
-							error!("Migration: Invalid roomserverid in db.");
-							continue;
-						},
+					let Some(servername) = parts.next() else {
+						error!("Migration: Invalid roomserverid in db.");
+						continue;
 					};
 					let mut serverroomid = servername.to_vec();
 					serverroomid.push(0xFF);
@@ -771,7 +768,7 @@ pub async fn load_or_create(config: Config) -> Result<()> {
 				}
 
 				// Force E2EE device list updates so we can send them over federation
-				for user_id in services().users.iter().filter_map(std::result::Result::ok) {
+				for user_id in services().users.iter().filter_map(Result::ok) {
 					services().users.mark_device_key_update(&user_id)?;
 				}
 
@@ -929,7 +926,7 @@ pub async fn load_or_create(config: Config) -> Result<()> {
 					for user_id in services()
 						.users
 						.iter()
-						.filter_map(std::result::Result::ok)
+						.filter_map(Result::ok)
 						.filter(|user| !services().users.is_deactivated(user).unwrap_or(true))
 						.filter(|user| user.server_name() == services().globals.server_name())
 					{