silenced a bunch of misleading Clippy warnings; fixed a possible performance bug

* There were a bunch of code quality Clippy warnings that
  didn't apply for various reasons.

* There was an ok_or() that should have been an ok_or_else().

Author: BartMassey

src/algorithms.rs

@@ -347,6 +347,7 @@ fn bigint_from_slice(slice: &[BigDigit]) -> BigInt {
     BigInt::from(biguint_from_vec(slice.to_vec()))
 }
 
+#[allow(clippy::many_single_char_names)]
 /// Three argument multiply accumulate:
 /// acc += b * c
 fn mac3(acc: &mut [BigDigit], b: &[BigDigit], c: &[BigDigit]) {

src/bigint.rs

@@ -2707,7 +2707,9 @@ impl TryFrom<&BigInt> for BigUint {
 
     #[inline]
     fn try_from(value: &BigInt) -> Result<BigUint, TryFromBigIntError<()>> {
-        value.to_biguint().ok_or(TryFromBigIntError::new(()))
+        value
+            .to_biguint()
+            .ok_or_else(|| TryFromBigIntError::new(()))
     }
 }
 

src/biguint.rs

@@ -1811,10 +1811,15 @@ impl Roots for BigUint {
     }
 }
 
+#[allow(clippy::useless_conversion)]
 fn high_bits_to_u64(v: &BigUint) -> u64 {
     match v.data.len() {
         0 => 0,
-        1 => u64::from(v.data[0]),
+        1 =>
+        {
+            #[allow(clippy::useless_conversion)]
+            u64::from(v.data[0])
+        }
         _ => {
             let mut bits = v.bits();
             let mut ret = 0u64;
@@ -1827,6 +1832,7 @@ fn high_bits_to_u64(v: &BigUint) -> u64 {
                 if bits_want != 64 {
                     ret <<= bits_want;
                 }
+                // XXX Conversion is useless if already 64-bit.
                 ret |= u64::from(*d) >> (digit_bits - bits_want);
                 ret_bits += bits_want;
                 bits -= bits_want;
@@ -1852,6 +1858,7 @@ impl ToPrimitive for BigUint {
         self.to_u128().as_ref().and_then(u128::to_i128)
     }
 
+    #[allow(clippy::useless_conversion)]
     #[inline]
     fn to_u64(&self) -> Option<u64> {
         let mut ret: u64 = 0;
@@ -1862,6 +1869,7 @@ impl ToPrimitive for BigUint {
                 return None;
             }
 
+            // XXX Conversion is useless if already 64-bit.
             ret += u64::from(*i) << bits;
             bits += big_digit::BITS;
         }

src/monty.rs

@@ -34,6 +34,7 @@ impl MontyReducer {
     }
 }
 
+#[allow(clippy::many_single_char_names)]
 /// Computes z mod m = x * y * 2 ** (-n*_W) mod m
 /// assuming k = -1/m mod 2**_W
 /// See Gueron, "Efficient Software Implementations of Modular Exponentiation".
@@ -130,6 +131,7 @@ fn mul_add_www(x: BigDigit, y: BigDigit, c: BigDigit) -> (BigDigit, BigDigit) {
     ((z >> big_digit::BITS) as BigDigit, z as BigDigit)
 }
 
+#[allow(clippy::many_single_char_names)]
 /// Calculates x ** y mod m using a fixed, 4-bit window.
 pub(crate) fn monty_modpow(x: &BigUint, y: &BigUint, m: &BigUint) -> BigUint {
     assert!(m.data[0] & 1 == 1);