Prefer vec! macro.

  - The vec![] macro is more performant and often easier to read than
    multiple push calls.

  - Allow push to a Vec straight after creation in tests. Performance
    is not that great of an issue in tests, and the fix would impact
    legibility.

  - Found by clippy::vec_init_then_push.

5 files changed, 19 insertions, 16 deletions

diff --git a/ffi-macros/src/lib.rs b/ffi-macros/src/lib.rs
index 5c92a302..d6195d2a 100644
--- a/ffi-macros/src/lib.rs
+++ b/ffi-macros/src/lib.rs
@@ -310,8 +310,7 @@ fn ident2c(ident: &syn::Ident) -> String {
         }
     }
 
-    let mut previous_is_uppercase = Vec::new();
-    previous_is_uppercase.push(true);
+    let mut previous_is_uppercase = vec![true];
     previous_is_uppercase.extend(ident.iter().map(|c| c.is_uppercase()));
 
     for (c, previous_is_upper) in ident.iter().zip(previous_is_uppercase)
diff --git a/openpgp/src/crypto/hash.rs b/openpgp/src/crypto/hash.rs
index 10ed9787..b78f1a20 100644
--- a/openpgp/src/crypto/hash.rs
+++ b/openpgp/src/crypto/hash.rs
@@ -490,11 +490,12 @@ impl Signature4 {
 
         // This code assumes that the signature has been verified
         // prior to being confirmed, so it is well-formed.
-        let mut body = Vec::new();
-        body.push(self.version());
-        body.push(self.typ().into());
-        body.push(self.pk_algo().into());
-        body.push(self.hash_algo().into());
+        let mut body = vec![
+            self.version(),
+            self.typ().into(),
+            self.pk_algo().into(),
+            self.hash_algo().into(),
+        ];
 
         // The hashed area.
         let l = self.hashed_area().serialized_len()
diff --git a/openpgp/src/message/mod.rs b/openpgp/src/message/mod.rs
index 662e4e02..0967607e 100644
--- a/openpgp/src/message/mod.rs
+++ b/openpgp/src/message/mod.rs
@@ -799,6 +799,7 @@ mod tests {
         assert!(message.is_ok(), "{:?}", message);
     }
 
+    #[allow(clippy::vec_init_then_push)]
     #[test]
     fn compressed_part() {
         let mut lit = Literal::new(Text);
@@ -861,6 +862,7 @@ mod tests {
         assert!(message.is_ok(), "{:?}", message);
     }
 
+    #[allow(clippy::vec_init_then_push)]
     #[test]
     fn one_pass_sig_part() {
         let mut lit = Literal::new(Text);
@@ -973,6 +975,7 @@ mod tests {
         assert!(message.is_ok(), "{:?}", message);
     }
 
+    #[allow(clippy::vec_init_then_push)]
     #[test]
     fn signature_part() {
         let mut lit = Literal::new(Text);
diff --git a/openpgp/src/packet/key.rs b/openpgp/src/packet/key.rs
index 6e75c604..ef49a291 100644
--- a/openpgp/src/packet/key.rs
+++ b/openpgp/src/packet/key.rs
@@ -1404,10 +1404,9 @@ assert_send_and_sync!(Unencrypted);
 impl From<mpi::SecretKeyMaterial> for Unencrypted {
     fn from(mpis: mpi::SecretKeyMaterial) -> Self {
         use crate::serialize::Marshal;
-        let mut plaintext = Vec::new();
         // We need to store the type.
-        plaintext.push(
-            mpis.algo().unwrap_or(PublicKeyAlgorithm::Unknown(0)).into());
+        let mut plaintext =
+            vec![mpis.algo().unwrap_or(PublicKeyAlgorithm::Unknown(0)).into()];
         mpis.serialize(&mut plaintext)
             .expect("MPI serialization to vec failed");
         Unencrypted { mpis: mem::Encrypted::new(plaintext.into()), }
diff --git a/sq/src/commands/key.rs b/sq/src/commands/key.rs
index fc1c5a85..23cae863 100644
--- a/sq/src/commands/key.rs
+++ b/sq/src/commands/key.rs
@@ -216,10 +216,11 @@ fn password(config: Config, m: &ArgMatches) -> Result<()> {
 
     // First, decrypt all secrets.
     let passwords = &mut Vec::new();
-    let mut decrypted: Vec<Packet> = Vec::new();
-    decrypted.push(decrypt_key(
+    let mut decrypted: Vec<Packet> = vec![decrypt_key(
         key.primary_key().key().clone().parts_into_secret()?,
-        passwords)?.into());
+        passwords,
+    )?
+    .into()];
     for ka in key.keys().subkeys().secret() {
         decrypted.push(decrypt_key(
             ka.key().clone().parts_into_secret()?,
@@ -252,10 +253,10 @@ fn password(config: Config, m: &ArgMatches) -> Result<()> {
     };
 
     if let Some(new) = new_password {
-        let mut encrypted: Vec<Packet> = Vec::new();
-        encrypted.push(
+        let mut encrypted: Vec<Packet> = vec![
             key.primary_key().key().clone().parts_into_secret()?
-                .encrypt_secret(&new)?.into());
+                .encrypt_secret(&new)?.into()
+        ];
         for ka in key.keys().subkeys().unencrypted_secret() {
             encrypted.push(
                 ka.key().clone().parts_into_secret()?