Lint: Use lazy evaluation.

  - https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call

18 files changed, 28 insertions, 28 deletions

diff --git a/ffi-macros/src/lib.rs b/ffi-macros/src/lib.rs
index 0a1efc1d..6eebc9a3 100644
--- a/ffi-macros/src/lib.rs
+++ b/ffi-macros/src/lib.rs
@@ -258,8 +258,8 @@ pub fn ffi_wrapper_type(args: TokenStream, input: TokenStream) -> TokenStream {
     }
 
     let wrapper = st.ident.clone();
-    let name = name.unwrap_or(ident2c(&st.ident));
-    let prefix = prefix.unwrap_or("".into());
+    let name = name.unwrap_or_else(|| ident2c(&st.ident));
+    let prefix = prefix.unwrap_or_else(|| "".into());
 
     // Parse the type of the wrapped object.
     let argument_span = st.fields.span();
diff --git a/ffi/tests/c-tests.rs b/ffi/tests/c-tests.rs
index e5af5c1f..4dd5f616 100644
--- a/ffi/tests/c-tests.rs
+++ b/ffi/tests/c-tests.rs
@@ -230,7 +230,7 @@ fn build(include_dirs: &[PathBuf], ldpath: &Path, target_dir: &Path,
         .collect::<Vec<String>>().join(" ");
     let st = Command::new("make")
         .env("CFLAGS", &format!("-Wall -O0 -ggdb {} {}", includes,
-                                env::var("CFLAGS").unwrap_or("".into())))
+                                env::var("CFLAGS").unwrap_or_else(|_| "".into())))
         .env("LDFLAGS", &format!("-L{:?}", ldpath))
         .env("LDLIBS", "-lsequoia_ffi")
         .arg("-C").arg(&target_dir)
diff --git a/ipc/src/core.rs b/ipc/src/core.rs
index 06adc353..56522ccd 100644
--- a/ipc/src/core.rs
+++ b/ipc/src/core.rs
@@ -186,7 +186,7 @@ impl Config {
         } else {
             if home_not_set {
                 c.home =
-                    dirs::home_dir().ok_or(
+                    dirs::home_dir().ok_or_else(||
                         anyhow::anyhow!("Failed to get users home directory"))?
                 .join(".sequoia");
             }
diff --git a/net/src/lib.rs b/net/src/lib.rs
index 8410de37..bb18f55b 100644
--- a/net/src/lib.rs
+++ b/net/src/lib.rs
@@ -292,7 +292,7 @@ impl KeyServer {
                                          -> Result<Vec<Cert>>
     {
         let userid = userid.into();
-        let email = userid.email().and_then(|addr| addr.ok_or(
+        let email = userid.email().and_then(|addr| addr.ok_or_else(||
             openpgp::Error::InvalidArgument(
                 "UserID does not contain an email address".into()).into()))?;
         let uri = self.uri.join(
diff --git a/openpgp-ffi/tests/c-tests.rs b/openpgp-ffi/tests/c-tests.rs
index 30dc3bc8..33a52261 100644
--- a/openpgp-ffi/tests/c-tests.rs
+++ b/openpgp-ffi/tests/c-tests.rs
@@ -229,7 +229,7 @@ fn build(include_dirs: &[PathBuf], ldpath: &Path, target_dir: &Path,
         .collect::<Vec<String>>().join(" ");
     let st = Command::new("make")
         .env("CFLAGS", &format!("-Wall -O0 -ggdb {} {}", includes,
-                                env::var("CFLAGS").unwrap_or("".into())))
+                                env::var("CFLAGS").unwrap_or_else(|_| "".into())))
         .env("LDFLAGS", &format!("-L{:?}", ldpath))
         .env("LDLIBS", "-lsequoia_openpgp_ffi")
         .arg("-C").arg(&target_dir)
diff --git a/openpgp/src/armor.rs b/openpgp/src/armor.rs
index 837e3b3a..dbe007c8 100644
--- a/openpgp/src/armor.rs
+++ b/openpgp/src/armor.rs
@@ -721,7 +721,7 @@ impl<'a> Reader<'a> {
     )
         -> Self
     {
-        let mode = mode.unwrap_or(Default::default());
+        let mode = mode.unwrap_or_default();
 
         Reader {
             // The embedded generic reader's fields.
diff --git a/openpgp/src/cert/amalgamation.rs b/openpgp/src/cert/amalgamation.rs
index 3d291353..8433e43f 100644
--- a/openpgp/src/cert/amalgamation.rs
+++ b/openpgp/src/cert/amalgamation.rs
@@ -1150,7 +1150,7 @@ impl<'a, C> ValidComponentAmalgamation<'a, C>
             .ok_or_else(|| {
                 error.map(|e| e.context(format!(
                     "No binding signature at time {}", crate::fmt::time(&t))))
-                    .unwrap_or(Error::NoBindingSignature(t).into())
+                    .unwrap_or_else(|| Error::NoBindingSignature(t).into())
             })
             .and_then(|c| ComponentAmalgamation::new(cert, (c.0).0)
                       .with_policy_relaxed(policy, t, valid_cert))
diff --git a/openpgp/src/cert/builder.rs b/openpgp/src/cert/builder.rs
index 65b9df86..84e7810e 100644
--- a/openpgp/src/cert/builder.rs
+++ b/openpgp/src/cert/builder.rs
@@ -260,7 +260,7 @@ impl CertBuilder<'_> {
     {
         CertBuilder {
             creation_time: None,
-            ciphersuite: ciphersuite.into().unwrap_or(Default::default()),
+            ciphersuite: ciphersuite.into().unwrap_or_default(),
             primary: KeyBlueprint {
                 flags: KeyFlags::empty()
                     .set_certification(),
diff --git a/openpgp/src/cert/parser/mod.rs b/openpgp/src/cert/parser/mod.rs
index af5f2a38..2d62dc58 100644
--- a/openpgp/src/cert/parser/mod.rs
+++ b/openpgp/src/cert/parser/mod.rs
@@ -982,7 +982,7 @@ impl<'a> Iterator for CertParser<'a> {
                                    _ => None,
                                }
                                .map(|s| format!(", {}", s))
-                               .unwrap_or("".into())
+                               .unwrap_or_else(|| "".into())
                             );
                             self.source = Some(iter);
                             self.parse(packet)
diff --git a/openpgp/src/lib.rs b/openpgp/src/lib.rs
index da44fb4c..43b28657 100644
--- a/openpgp/src/lib.rs
+++ b/openpgp/src/lib.rs
@@ -305,7 +305,7 @@ pub enum Error {
     /// determined to no longer be secure.
     #[error("{0} is not considered secure{}",
             .1.as_ref().map(|t| format!(" since {}", crate::fmt::time(t)))
-            .unwrap_or("".into()))]
+            .unwrap_or_else(|| "".into()))]
     PolicyViolation(String, Option<std::time::SystemTime>),
 }
 
diff --git a/openpgp/src/policy.rs b/openpgp/src/policy.rs
index bb86c631..c915d06d 100644
--- a/openpgp/src/policy.rs
+++ b/openpgp/src/policy.rs
@@ -765,7 +765,7 @@ fn system_time_cutoff_to_timestamp(t: SystemTime) -> Option<Timestamp> {
         // An error can only occur if the SystemTime is less than the
         // reference time (SystemTime::UNIX_EPOCH).  Map that to
         // SystemTime::UNIX_EPOCH, as above.
-        .unwrap_or(Duration::new(0, 0));
+        .unwrap_or_else(|_| Duration::new(0, 0));
     let t = t.as_secs();
     if t > u32::MAX as u64 {
         // Map to None, as above.
diff --git a/openpgp/src/policy/cutofflist.rs b/openpgp/src/policy/cutofflist.rs
index 47d1d3e5..98d4af78 100644
--- a/openpgp/src/policy/cutofflist.rs
+++ b/openpgp/src/policy/cutofflist.rs
@@ -162,7 +162,7 @@ impl<A> CutoffList<A>
     {
         if let Some(cutoff) = self.cutoff(a.clone()) {
             let cutoff = cutoff
-                .checked_add(tolerance.unwrap_or(Duration::seconds(0)))
+                .checked_add(tolerance.unwrap_or_else(|| Duration::seconds(0)))
                 .unwrap_or(Timestamp::MAX);
             if time >= cutoff {
                 Err(Error::PolicyViolation(
diff --git a/sq/src/commands/autocrypt.rs b/sq/src/commands/autocrypt.rs
index f498c5b7..ac852958 100644
--- a/sq/src/commands/autocrypt.rs
+++ b/sq/src/commands/autocrypt.rs
@@ -43,7 +43,7 @@ pub fn dispatch(config: Config, m: &clap::ArgMatches) -> Result<()> {
             let ac = autocrypt::AutocryptHeader::new_sender(
                 &config.policy,
                 &cert,
-                &addr.ok_or(anyhow::anyhow!(
+                &addr.ok_or_else(|| anyhow::anyhow!(
                     "No well-formed primary userid found, use \
                      --address to specify one"))?,
                 m.value_of("prefer-encrypt").expect("has default"))?;
diff --git a/sq/src/commands/certify.rs b/sq/src/commands/certify.rs
index 725fbc80..8779e5e3 100644
--- a/sq/src/commands/certify.rs
+++ b/sq/src/commands/certify.rs
@@ -29,7 +29,7 @@ pub fn certify(config: Config, m: &clap::ArgMatches)
     let trust_amount: u8 = m.value_of("amount")
         .map(|s| s.parse()).unwrap_or(Ok(120))?;
     let regex = m.values_of("regex").map(|v| v.collect::<Vec<_>>())
-        .unwrap_or(vec![]);
+        .unwrap_or_default();
     if trust_depth == 0 && regex.len() > 0 {
         return Err(
             anyhow::format_err!("A regex only makes sense \
diff --git a/sq/src/commands/keyring.rs b/sq/src/commands/keyring.rs
index be8fae21..a7083c1d 100644
--- a/sq/src/commands/keyring.rs
+++ b/sq/src/commands/keyring.rs
@@ -171,7 +171,7 @@ pub fn dispatch(config: Config, m: &clap::ArgMatches) -> Result<()> {
                         p.file_name().map(|f| String::from(f.to_string_lossy()))
                     })
                     // ... or we use a generic prefix...
-                        .unwrap_or(String::from("output"))
+                        .unwrap_or_else(|| String::from("output"))
                     // ... finally, add a hyphen to the derived prefix.
                         + "-");
             split(&mut input, &prefix, m.is_present("binary"))
diff --git a/sq/src/sq.rs b/sq/src/sq.rs
index 2fef196f..e179b8b6 100644
--- a/sq/src/sq.rs
+++ b/sq/src/sq.rs
@@ -413,7 +413,7 @@ fn main() -> Result<()> {
                 config.create_or_stdout_safe(m.value_of("output"))?;
             let certs = m.values_of("sender-cert-file")
                 .map(load_certs)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             // Fancy default for --signatures.  If you change this,
             // also change the description in the CLI definition.
             let signatures: usize =
@@ -431,7 +431,7 @@ fn main() -> Result<()> {
                 };
             let secrets = m.values_of("secret-key-file")
                 .map(load_keys)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             commands::decrypt(config,
                               &mut input, &mut output,
                               signatures, certs, secrets,
@@ -441,7 +441,7 @@ fn main() -> Result<()> {
         ("encrypt",  Some(m)) => {
             let recipients = m.values_of("recipients-cert-file")
                 .map(load_certs)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             let mut input = open_or_stdin(m.value_of("input"))?;
             let output =
                 config.create_or_stdout_pgp(m.value_of("output"),
@@ -449,7 +449,7 @@ fn main() -> Result<()> {
                                             armor::Kind::Message)?;
             let additional_secrets = m.values_of("signer-key-file")
                 .map(load_keys)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             let mode = match m.value_of("mode").expect("has default") {
                 "rest" => KeyFlags::empty()
                     .set_storage_encryption(),
@@ -485,7 +485,7 @@ fn main() -> Result<()> {
             let notarize = m.is_present("notarize");
             let secrets = m.values_of("secret-key-file")
                 .map(load_keys)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             let time = if let Some(time) = m.value_of("time") {
                 Some(parse_iso8601(time, chrono::NaiveTime::from_hms(0, 0, 0))
                          .context(format!("Bad value passed to --time: {:?}",
@@ -543,7 +543,7 @@ fn main() -> Result<()> {
                 m.value_of("signatures").expect("has a default").parse()?;
             let certs = m.values_of("sender-cert-file")
                 .map(load_certs)
-                .unwrap_or(Ok(vec![]))?;
+                .unwrap_or_else(|| Ok(vec![]))?;
             commands::verify(config, &mut input,
                              detached.as_mut().map(|r| r as &mut (dyn io::Read + Sync + Send)),
                              &mut output, signatures, certs)?;
@@ -642,7 +642,7 @@ fn main() -> Result<()> {
                                                 armor::Kind::Message)?;
                 let secrets = m.values_of("secret-key-file")
                     .map(load_keys)
-                    .unwrap_or(Ok(vec![]))?;
+                    .unwrap_or_else(|| Ok(vec![]))?;
                 commands::decrypt::decrypt_unwrap(
                     config,
                     &mut input, &mut output,
@@ -663,7 +663,7 @@ fn main() -> Result<()> {
                             p.file_name().map(|f| String::from(f.to_string_lossy()))
                         })
                         // ... or we use a generic prefix...
-                            .unwrap_or(String::from("output"))
+                            .unwrap_or_else(|| String::from("output"))
                         // ... finally, add a hyphen to the derived prefix.
                             + "-");
                 commands::split(&mut input, &prefix)?;
diff --git a/store/src/backend/mod.rs b/store/src/backend/mod.rs
index 2da08201..cbfe1f90 100644
--- a/store/src/backend/mod.rs
+++ b/store/src/backend/mod.rs
@@ -915,7 +915,7 @@ impl KeyServer {
 
             let next = Self::need_update(&c, network_policy)
                 .map(|c| refresh_interval() / c)
-                .unwrap_or(min_sleep_time());
+                .unwrap_or_else(|_| min_sleep_time());
 
             if let Err(e) = cert.map(|t| key.merge(t)) {
                 key.error("Update unsuccessful",
@@ -939,7 +939,7 @@ impl KeyServer {
         loop {
             let duration = Self::update(&c, net::Policy::Encrypted).await;
 
-            let duration = duration.unwrap_or(min_sleep_time());
+            let duration = duration.unwrap_or_else(|_| min_sleep_time());
             tokio::time::delay_for(random_duration(duration)).await;
         }
     }
@@ -990,7 +990,7 @@ impl node::key::Server for KeyServer {
             self.c.query_row(
                 "SELECT key FROM keys WHERE id = ?1",
                 &[&self.id],
-                |row| Ok(row.get(0).unwrap_or(vec![]))));
+                |row| Ok(row.get(0).unwrap_or_default())));
         pry!(pry!(results.get().get_result()).set_ok(key.as_slice()));
         Promise::ok(())
     }
diff --git a/store/src/lib.rs b/store/src/lib.rs
index ce437669..7c6041d9 100644
--- a/store/src/lib.rs
+++ b/store/src/lib.rs
@@ -1139,7 +1139,7 @@ impl Iterator for LogIter {
                              r.get_error().ok()
                          } else {
                              None
-                         }).ok_or(Error::StoreError.into()))
+                         }).ok_or_else(|| Error::StoreError.into()))
         };
         doit().ok()
     }