Remove unnecessary slicing.

  - Found by clippy::redundant_slicing.

8 files changed, 58 insertions, 58 deletions

diff --git a/autocrypt/src/lib.rs b/autocrypt/src/lib.rs
index 78f73486..b0cb7473 100644
--- a/autocrypt/src/lib.rs
+++ b/autocrypt/src/lib.rs
@@ -506,11 +506,11 @@ impl AutocryptSetupMessage {
         let mut headers : Vec<(&str, &str)> = Vec::new();
         if let Some(ref format) = self.passcode_format {
             headers.push(
-                (&"Passphrase-Format"[..], &format[..]));
+                ("Passphrase-Format", &format[..]));
         }
         if let Some(ref begin) = self.passcode_begin {
             headers.push(
-                (&"Passphrase-Begin"[..], &begin[..]));
+                ("Passphrase-Begin", &begin[..]));
         }
 
         let mut armor_writer =
@@ -528,7 +528,7 @@ impl AutocryptSetupMessage {
             let mut w = armor::Writer::with_headers(
                 m, armor::Kind::SecretKey,
                 vec![("Autocrypt-Prefer-Encrypt",
-                      self.prefer_encrypt().unwrap_or(&"nopreference"[..]))])?;
+                      self.prefer_encrypt().unwrap_or("nopreference"))])?;
 
             self.cert.as_tsk().serialize(&mut w)?;
             let m = w.finalize()?;
diff --git a/openpgp/src/armor.rs b/openpgp/src/armor.rs
index 676bc306..eb6bc65f 100644
--- a/openpgp/src/armor.rs
+++ b/openpgp/src/armor.rs
@@ -1085,7 +1085,7 @@ impl<'a> Reader<'a> {
             // it couldn't is if we encountered EOF.  We need to strip
             // it.  But, if it ends with \r\n, then we also want to
             // strip the \r too.
-            let line = if let Some(rest) = line.strip_suffix(&"\r\n"[..]) {
+            let line = if let Some(rest) = line.strip_suffix("\r\n") {
                 // \r\n.
                 rest
             } else if let Some(rest) = line.strip_suffix('\n') {
@@ -2059,12 +2059,12 @@ mod test {
     #[test]
     fn dearmor_yuge() {
         let yuge_key = crate::tests::key("yuge-key-so-yuge-the-yugest.asc");
-        let mut r = Reader::new(Cursor::new(&yuge_key[..]),
+        let mut r = Reader::new(Cursor::new(yuge_key),
                                 ReaderMode::VeryTolerant);
         let mut dearmored = Vec::<u8>::new();
         r.read_to_end(&mut dearmored).unwrap();
 
-        let r = Reader::new(Cursor::new(&yuge_key[..]),
+        let r = Reader::new(Cursor::new(yuge_key),
                             ReaderMode::VeryTolerant);
         let mut dearmored = Vec::<u8>::new();
         for c in r.bytes() {
diff --git a/openpgp/src/cert.rs b/openpgp/src/cert.rs
index 3ab5ce65..d9f7decd 100644
--- a/openpgp/src/cert.rs
+++ b/openpgp/src/cert.rs
@@ -4097,8 +4097,8 @@ mod test {
 
         // Keyring with two good keys
         let mut combined = vec![];
-        combined.extend_from_slice(&dkg[..]);
-        combined.extend_from_slice(&dkg[..]);
+        combined.extend_from_slice(dkg);
+        combined.extend_from_slice(dkg);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4106,8 +4106,8 @@ mod test {
 
         // Keyring with a good key, and a bad key.
         let mut combined = vec![];
-        combined.extend_from_slice(&dkg[..]);
-        combined.extend_from_slice(&lutz[..]);
+        combined.extend_from_slice(dkg);
+        combined.extend_from_slice(lutz);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4115,8 +4115,8 @@ mod test {
 
         // Keyring with a bad key, and a good key.
         let mut combined = vec![];
-        combined.extend_from_slice(&lutz[..]);
-        combined.extend_from_slice(&dkg[..]);
+        combined.extend_from_slice(lutz);
+        combined.extend_from_slice(dkg);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4124,9 +4124,9 @@ mod test {
 
         // Keyring with a good key, a bad key, and a good key.
         let mut combined = vec![];
-        combined.extend_from_slice(&dkg[..]);
-        combined.extend_from_slice(&lutz[..]);
-        combined.extend_from_slice(&dkg[..]);
+        combined.extend_from_slice(dkg);
+        combined.extend_from_slice(lutz);
+        combined.extend_from_slice(dkg);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4134,9 +4134,9 @@ mod test {
 
         // Keyring with a good key, a bad key, and a bad key.
         let mut combined = vec![];
-        combined.extend_from_slice(&dkg[..]);
-        combined.extend_from_slice(&lutz[..]);
-        combined.extend_from_slice(&lutz[..]);
+        combined.extend_from_slice(dkg);
+        combined.extend_from_slice(lutz);
+        combined.extend_from_slice(lutz);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4144,10 +4144,10 @@ mod test {
 
         // Keyring with a good key, a bad key, a bad key, and a good key.
         let mut combined = vec![];
-        combined.extend_from_slice(&dkg[..]);
-        combined.extend_from_slice(&lutz[..]);
-        combined.extend_from_slice(&lutz[..]);
-        combined.extend_from_slice(&dkg[..]);
+        combined.extend_from_slice(dkg);
+        combined.extend_from_slice(lutz);
+        combined.extend_from_slice(lutz);
+        combined.extend_from_slice(dkg);
         let certs = CertParser::from_bytes(&combined[..]).unwrap()
             .map(|certr| certr.is_ok())
             .collect::<Vec<bool>>();
@@ -4208,7 +4208,7 @@ mod test {
         let cert = Cert::from_bytes(crate::tests::key("already-revoked.pgp")).unwrap();
 
         let rev = crate::tests::key("already-revoked.rev");
-        let rev = PacketPile::from_reader(armor::Reader::new(&rev[..], None))
+        let rev = PacketPile::from_reader(armor::Reader::new(rev, None))
             .unwrap();
 
         let rev : Vec<Packet> = rev.into_children().collect();
diff --git a/openpgp/src/crypto/symmetric.rs b/openpgp/src/crypto/symmetric.rs
index fcfd1d23..ea4beb11 100644
--- a/openpgp/src/crypto/symmetric.rs
+++ b/openpgp/src/crypto/symmetric.rs
@@ -565,7 +565,7 @@ mod tests {
                 decryptor.read_to_end(&mut plaintext).unwrap();
             }
 
-            assert_eq!(&plaintext[..], &crate::tests::manifesto()[..]);
+            assert_eq!(&plaintext[..], crate::tests::manifesto());
         }
     }
 }
diff --git a/openpgp/src/packet/signature.rs b/openpgp/src/packet/signature.rs
index bc48b733..81ec439f 100644
--- a/openpgp/src/packet/signature.rs
+++ b/openpgp/src/packet/signature.rs
@@ -3167,48 +3167,48 @@ mod test {
 
         let tests = [
             Test {
-                key: &"neal.pgp"[..],
-                data: &"signed-1.gpg"[..],
+                key: "neal.pgp",
+                data: "signed-1.gpg",
                 good: 1,
             },
             Test {
-                key: &"neal.pgp"[..],
-                data: &"signed-1-sha1-neal.gpg"[..],
+                key: "neal.pgp",
+                data: "signed-1-sha1-neal.gpg",
                 good: 1,
             },
             Test {
-                key: &"testy.pgp"[..],
-                data: &"signed-1-sha256-testy.gpg"[..],
+                key: "testy.pgp",
+                data: "signed-1-sha256-testy.gpg",
                 good: 1,
             },
             Test {
-                key: &"dennis-simon-anton.pgp"[..],
-                data: &"signed-1-dsa.pgp"[..],
+                key: "dennis-simon-anton.pgp",
+                data: "signed-1-dsa.pgp",
                 good: 1,
             },
             Test {
-                key: &"erika-corinna-daniela-simone-antonia-nistp256.pgp"[..],
-                data: &"signed-1-ecdsa-nistp256.pgp"[..],
+                key: "erika-corinna-daniela-simone-antonia-nistp256.pgp",
+                data: "signed-1-ecdsa-nistp256.pgp",
                 good: 1,
             },
             Test {
-                key: &"erika-corinna-daniela-simone-antonia-nistp384.pgp"[..],
-                data: &"signed-1-ecdsa-nistp384.pgp"[..],
+                key: "erika-corinna-daniela-simone-antonia-nistp384.pgp",
+                data: "signed-1-ecdsa-nistp384.pgp",
                 good: 1,
             },
             Test {
-                key: &"erika-corinna-daniela-simone-antonia-nistp521.pgp"[..],
-                data: &"signed-1-ecdsa-nistp521.pgp"[..],
+                key: "erika-corinna-daniela-simone-antonia-nistp521.pgp",
+                data: "signed-1-ecdsa-nistp521.pgp",
                 good: 1,
             },
             Test {
-                key: &"emmelie-dorothea-dina-samantha-awina-ed25519.pgp"[..],
-                data: &"signed-1-eddsa-ed25519.pgp"[..],
+                key: "emmelie-dorothea-dina-samantha-awina-ed25519.pgp",
+                data: "signed-1-eddsa-ed25519.pgp",
                 good: 1,
             },
             Test {
-                key: &"emmelie-dorothea-dina-samantha-awina-ed25519.pgp"[..],
-                data: &"signed-twice-by-ed25519.pgp"[..],
+                key: "emmelie-dorothea-dina-samantha-awina-ed25519.pgp",
+                data: "signed-twice-by-ed25519.pgp",
                 good: 2,
             },
             Test {
@@ -3223,13 +3223,13 @@ mod test {
             },
             // Check with the wrong key.
             Test {
-                key: &"neal.pgp"[..],
-                data: &"signed-1-sha256-testy.gpg"[..],
+                key: "neal.pgp",
+                data: "signed-1-sha256-testy.gpg",
                 good: 0,
             },
             Test {
-                key: &"neal.pgp"[..],
-                data: &"signed-2-partial-body.gpg"[..],
+                key: "neal.pgp",
+                data: "signed-2-partial-body.gpg",
                 good: 1,
             },
         ];
@@ -3394,7 +3394,7 @@ mod test {
             panic!("Expected a Signature, got: {:?}", p);
         };
 
-        sig.verify_message(cert.primary_key().key(), &msg[..]).unwrap();
+        sig.verify_message(cert.primary_key().key(), msg).unwrap();
     }
 
     #[test]
diff --git a/openpgp/src/packet/skesk.rs b/openpgp/src/packet/skesk.rs
index 6628dd3d..d42b7d60 100644
--- a/openpgp/src/packet/skesk.rs
+++ b/openpgp/src/packet/skesk.rs
@@ -259,7 +259,7 @@ impl SKESK4 {
             let iv = vec![0u8; blk_sz];
             let mut dec  = self.sym_algo.make_decrypt_cfb(&key[..], iv)?;
             let mut plain: SessionKey = vec![0u8; esk.len()].into();
-            let cipher = &esk[..];
+            let cipher = esk;
 
             for (pl, ct)
                 in plain[..].chunks_mut(blk_sz).zip(cipher.chunks(blk_sz))
diff --git a/openpgp/src/parse.rs b/openpgp/src/parse.rs
index 0fb5ccae..ede6d182 100644
--- a/openpgp/src/parse.rs
+++ b/openpgp/src/parse.rs
@@ -2512,7 +2512,7 @@ fn literal_parser_test () {
 
             let expected = crate::tests::manifesto();
 
-            assert_eq!(&content[..], &expected[..]);
+            assert_eq!(&content[..], expected);
         } else {
             panic!("Wrong packet!");
         }
@@ -2762,7 +2762,7 @@ fn skesk_parser_test() {
             match skesk.decrypt(&test.password) {
                 Ok((_sym_algo, key)) => {
                     let key = crate::fmt::to_hex(&key[..], false);
-                    assert_eq!(&key[..], &test.key_hex[..]);
+                    assert_eq!(&key[..], test.key_hex);
                 }
                 Err(e) => {
                     panic!("No session key, got: {:?}", e);
@@ -5862,7 +5862,7 @@ mod test {
         // that we don't try to recover.
         let mut msg2 = Vec::new();
         msg2.push(0);
-        msg2.extend_from_slice(&msg[..]);
+        msg2.extend_from_slice(msg);
 
         let ppr = PacketParserBuilder::from_bytes(&msg2[..]).unwrap()
             .dearmor(packet_parser_builder::Dearmor::Disabled)
@@ -5873,8 +5873,8 @@ mod test {
     /// Issue #141.
     #[test]
     fn truncated_packet() {
-        for msg in &[&crate::tests::message("literal-mode-b.gpg")[..],
-                     &crate::tests::message("literal-mode-t-partial-body.gpg")[..],
+        for msg in &[crate::tests::message("literal-mode-b.gpg"),
+                     crate::tests::message("literal-mode-t-partial-body.gpg"),
         ] {
             // Make sure we can read the first packet.
             let ppr = PacketParserBuilder::from_bytes(msg).unwrap()
diff --git a/openpgp/src/serialize.rs b/openpgp/src/serialize.rs
index 3f124004..1f1f4f89 100644
--- a/openpgp/src/serialize.rs
+++ b/openpgp/src/serialize.rs
@@ -3038,7 +3038,7 @@ mod test {
             let data = crate::tests::message(filename);
 
             // 2. Parse the message.
-            let pile = PacketPile::from_bytes(&data[..]).unwrap();
+            let pile = PacketPile::from_bytes(data).unwrap();
 
             // The following test only works if the message has a
             // single top-level packet.
@@ -3059,7 +3059,7 @@ mod test {
 
             // 4. Modulo the body length encoding, check that the
             // reserialized content is identical to the original data.
-            packets_bitwise_compare(filename, p, &data[..], &buffer[..]);
+            packets_bitwise_compare(filename, p, data, &buffer[..]);
         }
     }
 
@@ -3080,14 +3080,14 @@ mod test {
             let data = crate::tests::message(filename);
 
             // 2. Parse the message.
-            let u = Packet::Unknown(to_unknown_packet(&data[..]).unwrap());
+            let u = Packet::Unknown(to_unknown_packet(data).unwrap());
 
             // 3. Serialize the packet it into a local buffer.
             let data2 = (&u as &dyn MarshalInto).to_vec().unwrap();
 
             // 4. Modulo the body length encoding, check that the
             // reserialized content is identical to the original data.
-            packets_bitwise_compare(filename, &u, &data[..], &data2[..]);
+            packets_bitwise_compare(filename, &u, data, &data2[..]);
         }
 
     }
@@ -3125,7 +3125,7 @@ mod test {
             // never recurse so that the resulting message only
             // contains the top-level packets.  Any containers will
             // have their raw content stored in packet.content.
-            let pile = PacketParserBuilder::from_bytes(&data[..]).unwrap()
+            let pile = PacketParserBuilder::from_bytes(data).unwrap()
                 .max_recursion_depth(0)
                 .buffer_unread_content()
                 //.trace()