Port common, and most of crypto, to a more aggressive clippy

common/db/src/lib.rs

@@ -1,6 +1,8 @@
 use core::fmt::Debug;
+extern crate alloc;
+use alloc::sync::Arc;
 use std::{
-  sync::{Arc, RwLock},
+  sync::RwLock,
   collections::{HashSet, HashMap},
 };
 
@@ -23,7 +25,7 @@ pub trait Db: 'static + Send + Sync + Clone + Debug + Get {
   fn key(db_dst: &'static [u8], item_dst: &'static [u8], key: impl AsRef<[u8]>) -> Vec<u8> {
     let db_len = u8::try_from(db_dst.len()).unwrap();
     let dst_len = u8::try_from(item_dst.len()).unwrap();
-    [[db_len].as_ref(), db_dst, [dst_len].as_ref(), item_dst, key.as_ref()].concat().to_vec()
+    [[db_len].as_ref(), db_dst, [dst_len].as_ref(), item_dst, key.as_ref()].concat()
   }
   fn txn(&mut self) -> Self::Transaction<'_>;
 }
@@ -38,7 +40,7 @@ impl<'a> Get for MemDbTxn<'a> {
     if self.2.contains(key.as_ref()) {
       return None;
     }
-    self.1.get(key.as_ref()).cloned().or(self.0 .0.read().unwrap().get(key.as_ref()).cloned())
+    self.1.get(key.as_ref()).cloned().or_else(|| self.0 .0.read().unwrap().get(key.as_ref()).cloned())
   }
 }
 impl<'a> DbTxn for MemDbTxn<'a> {
@@ -66,22 +68,23 @@ impl<'a> DbTxn for MemDbTxn<'a> {
 pub struct MemDb(Arc<RwLock<HashMap<Vec<u8>, Vec<u8>>>>);
 
 impl PartialEq for MemDb {
-  fn eq(&self, other: &MemDb) -> bool {
+  fn eq(&self, other: &Self) -> bool {
     *self.0.read().unwrap() == *other.0.read().unwrap()
   }
 }
 impl Eq for MemDb {}
 
 impl Default for MemDb {
-  fn default() -> MemDb {
-    MemDb(Arc::new(RwLock::new(HashMap::new())))
+  fn default() -> Self {
+    Self(Arc::new(RwLock::new(HashMap::new())))
   }
 }
 
 impl MemDb {
   /// Create a new in-memory database.
-  pub fn new() -> MemDb {
-    MemDb::default()
+  #[must_use]
+  pub fn new() -> Self {
+    Self::default()
   }
 }
 

common/std-shims/src/io.rs

@@ -24,14 +24,17 @@ mod shims {
   }
 
   impl Error {
-    pub fn new<E: 'static + Send + Sync>(kind: ErrorKind, error: E) -> Error {
-      Error { kind, error: Box::new(error) }
+    #[must_use]
+    pub fn new<E: 'static + Send + Sync>(kind: ErrorKind, error: E) -> Self {
+      Self { kind, error: Box::new(error) }
     }
 
-    pub fn kind(&self) -> ErrorKind {
+    #[must_use]
+    pub const fn kind(&self) -> ErrorKind {
       self.kind
     }
 
+    #[must_use]
     pub fn into_inner(self) -> Option<Box<dyn Send + Sync>> {
       Some(self.error)
     }
@@ -53,10 +56,7 @@ mod shims {
 
   impl Read for &[u8] {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-      let mut read = buf.len();
-      if self.len() < buf.len() {
-        read = self.len();
-      }
+      let read = self.len().min(buf.len());
       buf[.. read].copy_from_slice(&self[.. read]);
       *self = &self[read ..];
       Ok(read)

common/std-shims/src/lib.rs

@@ -2,33 +2,20 @@
 #![doc = include_str!("../README.md")]
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[cfg(not(feature = "std"))]
-#[allow(unused_imports)]
-#[doc(hidden)]
-#[macro_use]
-pub extern crate alloc;
+extern crate alloc;
 
 pub mod sync;
 pub mod collections;
 pub mod io;
 
 pub mod vec {
-  #[cfg(not(feature = "std"))]
   pub use alloc::vec::*;
-  #[cfg(feature = "std")]
-  pub use std::vec::*;
 }
 
 pub mod str {
-  #[cfg(not(feature = "std"))]
   pub use alloc::str::*;
-  #[cfg(feature = "std")]
-  pub use std::str::*;
 }
 
 pub mod string {
-  #[cfg(not(feature = "std"))]
   pub use alloc::string::*;
-  #[cfg(feature = "std")]
-  pub use std::string::*;
 }

common/std-shims/src/sync.rs

@@ -32,24 +32,24 @@ mod oncelock_shim {
 
   pub struct OnceLock<T>(Mutex<bool>, Option<T>);
   impl<T> OnceLock<T> {
-    pub const fn new() -> OnceLock<T> {
-      OnceLock(Mutex::new(false), None)
+    pub const fn new() ->  Self {
+      Self(Mutex::new(false), None)
     }
 
     // These return a distinct Option in case of None so another caller using get_or_init doesn't
     // transform it from None to Some
     pub fn get(&self) -> Option<&T> {
-      if !*self.0.lock() {
-        None
-      } else {
+      if *self.0.lock() {
         self.1.as_ref()
+      } else {
+        None
       }
     }
     pub fn get_mut(&mut self) -> Option<&mut T> {
-      if !*self.0.lock() {
-        None
-      } else {
+      if *self.0.lock() {
         self.1.as_mut()
+      } else {
+        None
       }
     }
 
@@ -57,7 +57,7 @@ mod oncelock_shim {
       let mut lock = self.0.lock();
       if !*lock {
         unsafe {
-          (core::ptr::addr_of!(self.1) as *mut Option<_>).write_unaligned(Some(f()));
+          core::ptr::addr_of!(self.1).cast_mut().write_unaligned(Some(f()));
         }
       }
       *lock = true;