clippy

Author: link2xt

src/chat.rs

@@ -4894,7 +4894,7 @@ async fn set_contacts_by_fingerprints(
     for (fingerprint, addr) in fingerprint_addrs {
         let contact_addr = ContactAddress::new(addr)?;
         let contact =
-            Contact::add_or_lookup_ex(context, "", &contact_addr, &fingerprint, Origin::Hidden)
+            Contact::add_or_lookup_ex(context, "", &contact_addr, fingerprint, Origin::Hidden)
                 .await?
                 .0;
         contacts.insert(contact);

src/chat/chat_tests.rs

@@ -2654,17 +2654,17 @@ async fn test_chat_get_encryption_info() -> Result<()> {
 
     add_contact_to_chat(alice, chat_id, contact_bob).await?;
     assert_eq!(
-        chat_id.get_encryption_info(&alice).await?,
+        chat_id.get_encryption_info(alice).await?,
         "End-to-end encryption available\n\
          \n\
          [email protected]\n\
          CCCB 5AA9 F6E1 141C 9431\n\
          65F1 DB18 B18C BCF7 0487"
     );
 
-    add_contact_to_chat(&alice, chat_id, contact_fiona).await?;
+    add_contact_to_chat(alice, chat_id, contact_fiona).await?;
     assert_eq!(
-        chat_id.get_encryption_info(&alice).await?,
+        chat_id.get_encryption_info(alice).await?,
         "End-to-end encryption available\n\
          \n\
          [email protected]\n\
@@ -2678,7 +2678,7 @@ async fn test_chat_get_encryption_info() -> Result<()> {
 
     let email_chat = alice.create_email_chat(bob).await;
     assert_eq!(
-        email_chat.id.get_encryption_info(&alice).await?,
+        email_chat.id.get_encryption_info(alice).await?,
         "No encryption"
     );
 
@@ -2892,29 +2892,29 @@ async fn test_sync_blocked() -> Result<()> {
     let sent_msg = bob.send_text(ba_chat.id, "hi").await;
     let a0b_chat_id = alice0.recv_msg(&sent_msg).await.chat_id;
     alice1.recv_msg(&sent_msg).await;
-    let a0b_contact_id = alice0.add_or_lookup_contact_id(&bob).await;
+    let a0b_contact_id = alice0.add_or_lookup_contact_id(bob).await;
 
-    assert_eq!(alice1.get_pgp_chat(&bob).await.blocked, Blocked::Request);
+    assert_eq!(alice1.get_pgp_chat(bob).await.blocked, Blocked::Request);
     a0b_chat_id.accept(alice0).await?;
     sync(alice0, alice1).await;
-    assert_eq!(alice1.get_pgp_chat(&bob).await.blocked, Blocked::Not);
+    assert_eq!(alice1.get_pgp_chat(bob).await.blocked, Blocked::Not);
     a0b_chat_id.block(alice0).await?;
     sync(alice0, alice1).await;
-    assert_eq!(alice1.get_pgp_chat(&bob).await.blocked, Blocked::Yes);
+    assert_eq!(alice1.get_pgp_chat(bob).await.blocked, Blocked::Yes);
     a0b_chat_id.unblock(alice0).await?;
     sync(alice0, alice1).await;
-    assert_eq!(alice1.get_pgp_chat(&bob).await.blocked, Blocked::Not);
+    assert_eq!(alice1.get_pgp_chat(bob).await.blocked, Blocked::Not);
 
     // Unblocking a 1:1 chat doesn't unblock the contact currently.
     Contact::unblock(alice0, a0b_contact_id).await?;
 
-    assert!(!alice1.add_or_lookup_contact(&bob).await.is_blocked());
+    assert!(!alice1.add_or_lookup_contact(bob).await.is_blocked());
     Contact::block(alice0, a0b_contact_id).await?;
     sync(alice0, alice1).await;
-    assert!(alice1.add_or_lookup_contact(&bob).await.is_blocked());
+    assert!(alice1.add_or_lookup_contact(bob).await.is_blocked());
     Contact::unblock(alice0, a0b_contact_id).await?;
     sync(alice0, alice1).await;
-    assert!(!alice1.add_or_lookup_contact(&bob).await.is_blocked());
+    assert!(!alice1.add_or_lookup_contact(bob).await.is_blocked());
 
     // Test accepting and blocking groups. This way we test:
     // - Group chats synchronisation.
@@ -3221,7 +3221,7 @@ async fn test_sync_broadcast() -> Result<()> {
         a.set_config_bool(Config::SyncMsgs, true).await?;
     }
     let bob = &tcm.bob().await;
-    let a0b_contact_id = alice0.add_or_lookup_contact(&bob).await.id;
+    let a0b_contact_id = alice0.add_or_lookup_contact(bob).await.id;
 
     let a0_broadcast_id = create_broadcast_list(alice0).await?;
     sync(alice0, alice1).await;
@@ -3248,7 +3248,7 @@ async fn test_sync_broadcast() -> Result<()> {
     );
     let sent_msg = alice1.send_text(a1_broadcast_id, "hi").await;
     let msg = bob.recv_msg(&sent_msg).await;
-    let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
+    let chat = Chat::load_from_db(bob, msg.chat_id).await?;
     assert_eq!(chat.get_type(), Chattype::Mailinglist);
     let msg = alice0.recv_msg(&sent_msg).await;
     assert_eq!(msg.chat_id, a0_broadcast_id);

src/contact/contact_tests.rs

@@ -733,20 +733,20 @@ async fn test_contact_get_encrinfo() -> Result<()> {
     let bob = &tcm.bob().await;
 
     // Return error for special IDs
-    let encrinfo = Contact::get_encrinfo(&alice, ContactId::SELF).await;
+    let encrinfo = Contact::get_encrinfo(alice, ContactId::SELF).await;
     assert!(encrinfo.is_err());
-    let encrinfo = Contact::get_encrinfo(&alice, ContactId::DEVICE).await;
+    let encrinfo = Contact::get_encrinfo(alice, ContactId::DEVICE).await;
     assert!(encrinfo.is_err());
 
     let email_contact_bob_id = alice.add_or_lookup_email_contact_id(bob).await;
-    let encrinfo = Contact::get_encrinfo(&alice, email_contact_bob_id).await?;
+    let encrinfo = Contact::get_encrinfo(alice, email_contact_bob_id).await?;
     assert_eq!(encrinfo, "No encryption");
 
-    let contact = Contact::get_by_id(&alice, email_contact_bob_id).await?;
-    assert!(!contact.e2ee_avail(&alice).await?);
+    let contact = Contact::get_by_id(alice, email_contact_bob_id).await?;
+    assert!(!contact.e2ee_avail(alice).await?);
 
     let contact_bob_id = alice.add_or_lookup_contact_id(bob).await;
-    let encrinfo = Contact::get_encrinfo(&alice, contact_bob_id).await?;
+    let encrinfo = Contact::get_encrinfo(alice, contact_bob_id).await?;
     assert_eq!(
         encrinfo,
         "End-to-end encryption available.
@@ -760,8 +760,8 @@ [email protected] ([email protected]):
 CCCB 5AA9 F6E1 141C 9431
 65F1 DB18 B18C BCF7 0487"
     );
-    let contact = Contact::get_by_id(&alice, contact_bob_id).await?;
-    assert!(contact.e2ee_avail(&alice).await?);
+    let contact = Contact::get_by_id(alice, contact_bob_id).await?;
+    assert!(contact.e2ee_avail(alice).await?);
     Ok(())
 }
 
@@ -786,7 +786,7 @@ async fn test_synchronize_status() -> Result<()> {
     let chat = alice1.create_email_chat(bob).await;
 
     // Alice sends a message to Bob from the first device.
-    send_text_msg(&alice1, chat.id, "Hello".to_string()).await?;
+    send_text_msg(alice1, chat.id, "Hello".to_string()).await?;
     let sent_msg = alice1.pop_sent_msg().await;
 
     // Message is not encrypted.
@@ -804,7 +804,7 @@ async fn test_synchronize_status() -> Result<()> {
 
     // Alice sends encrypted message.
     let chat = alice1.create_chat(bob).await;
-    send_text_msg(&alice1, chat.id, "Hello".to_string()).await?;
+    send_text_msg(alice1, chat.id, "Hello".to_string()).await?;
     let sent_msg = alice1.pop_sent_msg().await;
 
     // Second message is encrypted.
@@ -850,7 +850,7 @@ async fn test_selfavatar_changed_event() -> Result<()> {
 
     // Alice sends a message.
     let alice1_chat_id = alice1.create_chat(bob).await.id;
-    send_text_msg(&alice1, alice1_chat_id, "Hello".to_string()).await?;
+    send_text_msg(alice1, alice1_chat_id, "Hello".to_string()).await?;
     let sent_msg = alice1.pop_sent_msg().await;
 
     // The message is encrypted.

src/imex/key_transfer.rs

@@ -313,20 +313,14 @@ mod tests {
         alice2.recv_msg(&sent).await;
         let msg = alice2.get_last_msg().await;
         assert!(msg.is_setupmessage());
-        assert_eq!(
-            crate::key::load_self_secret_keyring(&alice2).await?.len(),
-            0
-        );
+        assert_eq!(crate::key::load_self_secret_keyring(alice2).await?.len(), 0);
 
         // Transfer the key.
         tcm.section("Alice imports a key from Autocrypt Setup Message");
         alice2.set_config(Config::BccSelf, Some("0")).await?;
-        continue_key_transfer(&alice2, msg.id, &setup_code).await?;
+        continue_key_transfer(alice2, msg.id, &setup_code).await?;
         assert_eq!(alice2.get_config_bool(Config::BccSelf).await?, true);
-        assert_eq!(
-            crate::key::load_self_secret_keyring(&alice2).await?.len(),
-            1
-        );
+        assert_eq!(crate::key::load_self_secret_keyring(alice2).await?.len(), 1);
 
         // Alice sends a message to self from the new device.
         let sent = alice2.send_text(msg.chat_id, "Test").await;

src/message/message_tests.rs

@@ -200,7 +200,6 @@ async fn test_unencrypted_quote_encrypted_message() -> Result<()> {
 
     let bob_received_message = bob.recv_msg(&sent).await;
     assert_eq!(bob_received_message.get_showpadlock(), true);
-    let bob_chat_id = bob_received_message.chat_id;
 
     // Bob quotes encrypted message in unencrypted chat.
     let bob_email_chat = bob.create_email_chat(alice).await;

src/receive_imf.rs

@@ -324,7 +324,7 @@ pub(crate) async fn receive_imf_inner(
 
     let chat_id = if let Some(grpid) = mime_parser.get_chat_group_id() {
         if let Some((chat_id, _protected, _blocked)) =
-            chat::get_chat_id_by_grpid(context, &grpid).await?
+            chat::get_chat_id_by_grpid(context, grpid).await?
         {
             Some(chat_id)
         } else {
@@ -376,7 +376,7 @@ pub(crate) async fn receive_imf_inner(
             past_ids = lookup_pgp_contacts_by_address_list(
                 context,
                 &mime_parser.past_members,
-                &past_member_fingerprints,
+                past_member_fingerprints,
                 chat_id,
             )
             .await?;
@@ -385,15 +385,15 @@ pub(crate) async fn receive_imf_inner(
                 context,
                 &mime_parser.past_members,
                 &mime_parser.gossiped_keys,
-                &past_member_fingerprints,
+                past_member_fingerprints,
                 Origin::Hidden,
             )
             .await?;
         }
     } else {
         if pgp_to_ids.len() == 1
             && pgp_to_ids
-                .get(0)
+                .first()
                 .is_some_and(|contact_id| contact_id.is_some())
         {
             // There is a single recipient and we have
@@ -425,18 +425,17 @@ pub(crate) async fn receive_imf_inner(
 
     let received_msg;
     if mime_parser.get_header(HeaderDef::SecureJoin).is_some() {
-        let res;
-        if mime_parser.incoming {
-            res = handle_securejoin_handshake(context, &mut mime_parser, from_id)
+        let res = if mime_parser.incoming {
+            handle_securejoin_handshake(context, &mut mime_parser, from_id)
                 .await
-                .context("error in Secure-Join message handling")?;
+                .context("error in Secure-Join message handling")?
         } else {
             let to_id = to_ids.first().copied().flatten().unwrap_or(ContactId::SELF);
             // handshake may mark contacts as verified and must be processed before chats are created
-            res = observe_securejoin_on_other_device(context, &mime_parser, to_id)
+            observe_securejoin_on_other_device(context, &mime_parser, to_id)
                 .await
                 .context("error in Secure-Join watching")?
-        }
+        };
 
         match res {
             securejoin::HandshakeMessage::Done | securejoin::HandshakeMessage::Ignore => {
@@ -964,7 +963,7 @@ async fn add_parts(
                 context,
                 mime_parser,
                 &parent,
-                &to_ids,
+                to_ids,
                 from_id,
                 allow_creation || test_normal_chat.is_some(),
                 create_blocked,
@@ -2622,7 +2621,7 @@ async fn apply_group_changes(
                 context,
                 chat_id,
                 Some(from_id),
-                &to_ids,
+                to_ids,
                 past_ids,
                 chat_group_member_timestamps,
             )

src/receive_imf/receive_imf_tests.rs

@@ -4722,7 +4722,6 @@ async fn test_protected_group_add_remove_member_missing_key() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
     let bob = &tcm.bob().await;
-    let bob_addr = bob.get_config(Config::Addr).await?.unwrap();
     mark_as_verified(alice, bob).await;
     let group_id = create_group_chat(alice, ProtectionStatus::Protected, "Group").await?;
     let alice_bob_id = alice.add_or_lookup_contact(bob).await.id;
@@ -4731,7 +4730,6 @@ async fn test_protected_group_add_remove_member_missing_key() -> Result<()> {
     alice.sql.execute("DELETE FROM public_keys", ()).await?;
 
     let fiona = &tcm.fiona().await;
-    let fiona_addr = fiona.get_config(Config::Addr).await?.unwrap();
     mark_as_verified(alice, fiona).await;
     let alice_fiona_id = alice.add_or_lookup_contact(fiona).await.id;
     add_contact_to_chat(alice, group_id, alice_fiona_id).await?;

src/securejoin.rs

@@ -20,7 +20,6 @@ use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::param::Param;
 use crate::qr::check_qr;
 use crate::securejoin::bob::JoinerProgress;
-use crate::stock_str;
 use crate::sync::Sync::*;
 use crate::token;
 

src/securejoin/securejoin_tests.rs

@@ -350,10 +350,10 @@ async fn test_setup_contact_bob_knows_alice() -> Result<()> {
 
     tcm.section("Step 1: Generate QR-code");
     // `None` indicates setup-contact.
-    let qr = get_securejoin_qr(&alice, None).await?;
+    let qr = get_securejoin_qr(alice, None).await?;
 
     tcm.section("Step 2+4: Bob scans QR-code, sends vc-request-with-auth, skipping vc-request");
-    join_securejoin(&bob, &qr).await.unwrap();
+    join_securejoin(bob, &qr).await.unwrap();
 
     // Check Bob emitted the JoinerProgress event.
     let event = bob
@@ -388,11 +388,11 @@ async fn test_setup_contact_bob_knows_alice() -> Result<()> {
 
     // Alice should not yet have Bob verified
     let contact_bob = alice.add_or_lookup_pgp_contact(bob).await;
-    assert_eq!(contact_bob.is_verified(&alice).await?, false);
+    assert_eq!(contact_bob.is_verified(alice).await?, false);
 
     tcm.section("Step 5+6: Alice receives vc-request-with-auth, sends vc-contact-confirm");
     alice.recv_msg_trash(&sent).await;
-    assert_eq!(contact_bob.is_verified(&alice).await?, true);
+    assert_eq!(contact_bob.is_verified(alice).await?, true);
 
     let sent = alice.pop_sent_msg().await;
     let msg = bob.parse_msg(&sent).await;

src/stock_str.rs

@@ -778,11 +778,6 @@ pub(crate) async fn msg_grp_img_deleted(context: &Context, by_contact: ContactId
     }
 }
 
-/// Stock string: `End-to-end encryption preferred.`.
-pub(crate) async fn e2e_preferred(context: &Context) -> String {
-    translated(context, StockMessage::E2ePreferred).await
-}
-
 /// Stock string: `%1$s invited you to join this group. Waiting for the device of %2$s to reply…`.
 pub(crate) async fn secure_join_started(
     context: &Context,