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/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 => {

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/tests/aeap.rs

@@ -81,29 +81,29 @@ async fn check_aeap_transition(chat_for_transition: ChatForTransition, verified:
     }
 
     let mut groups = vec![
-        chat::create_group_chat(&bob, chat::ProtectionStatus::Unprotected, "Group 0")
+        chat::create_group_chat(bob, chat::ProtectionStatus::Unprotected, "Group 0")
             .await
             .unwrap(),
-        chat::create_group_chat(&bob, chat::ProtectionStatus::Unprotected, "Group 1")
+        chat::create_group_chat(bob, chat::ProtectionStatus::Unprotected, "Group 1")
             .await
             .unwrap(),
     ];
     if verified {
         groups.push(
-            chat::create_group_chat(&bob, chat::ProtectionStatus::Protected, "Group 2")
+            chat::create_group_chat(bob, chat::ProtectionStatus::Protected, "Group 2")
                 .await
                 .unwrap(),
         );
         groups.push(
-            chat::create_group_chat(&bob, chat::ProtectionStatus::Protected, "Group 3")
+            chat::create_group_chat(bob, chat::ProtectionStatus::Protected, "Group 3")
                 .await
                 .unwrap(),
         );
     }
 
-    let alice_contact = bob.add_or_lookup_contact_id(&alice).await;
+    let alice_contact = bob.add_or_lookup_contact_id(alice).await;
     for group in &groups {
-        chat::add_contact_to_chat(&bob, *group, alice_contact)
+        chat::add_contact_to_chat(bob, *group, alice_contact)
             .await
             .unwrap();
     }
@@ -121,12 +121,12 @@ async fn check_aeap_transition(chat_for_transition: ChatForTransition, verified:
         group3_alice = Some(alice.recv_msg(&sent).await.chat_id);
     }
 
-    tcm.change_addr(&alice, ALICE_NEW_ADDR).await;
+    tcm.change_addr(alice, ALICE_NEW_ADDR).await;
 
     tcm.section("Alice sends another message to Bob, this time from her new addr");
     // No matter which chat Alice sends to, the transition should be done in all groups
     let chat_to_send = match chat_for_transition {
-        OneToOne => alice.create_chat(&bob).await.id,
+        OneToOne => alice.create_chat(bob).await.id,
         GroupChat => group1_alice,
         VerifiedGroup => group3_alice.expect("No verified group"),
     };
@@ -141,7 +141,7 @@ async fn check_aeap_transition(chat_for_transition: ChatForTransition, verified:
     check_that_transition_worked(bob, &groups, alice_contact, ALICE_NEW_ADDR).await;
 
     tcm.section("Test switching back");
-    tcm.change_addr(&alice, "[email protected]").await;
+    tcm.change_addr(alice, "[email protected]").await;
     let sent = alice
         .send_text(chat_to_send, "Hello from my old addr!")
         .await;