Fix clippy::legacy_numeric_constants

Author: cuviper

ci/big_quickcheck/src/lib.rs

@@ -42,7 +42,7 @@ fn quickcheck_signed_eq_symmetric(a: BigInt, b: BigInt) -> bool {
 
 #[test]
 fn quickcheck_arith_primitive() {
- let gen = Gen::new(usize::max_value());
+ let gen = Gen::new(usize::MAX);
  let mut qc = QuickCheck::new().gen(gen);
 
  fn test_unsigned_add_primitive(a: usize, b: usize) -> TestResult {
@@ -280,7 +280,7 @@ fn quickcheck_signed_conversion(a: BigInt, radix: u8) -> TestResult {
 
 #[test]
 fn quicktest_shift() {
- let gen = Gen::new(usize::max_value());
+ let gen = Gen::new(usize::MAX);
  let mut qc = QuickCheck::new().gen(gen);
 
  fn test_shr_unsigned(a: u64, shift: u8) -> TestResult {
@@ -317,7 +317,7 @@ fn quicktest_shift() {
 
 #[test]
 fn quickcheck_modpow() {
- let gen = Gen::new(usize::max_value());
+ let gen = Gen::new(usize::MAX);
  let mut qc = QuickCheck::new().gen(gen);
 
  fn simple_modpow(base: &BigInt, exponent: &BigInt, modulus: &BigInt) -> BigInt {
@@ -360,7 +360,7 @@ fn quickcheck_modpow() {
 
 #[test]
 fn quickcheck_modinv() {
- let gen = Gen::new(usize::max_value());
+ let gen = Gen::new(usize::MAX);
  let mut qc = QuickCheck::new().gen(gen);
 
  fn test_modinv(value: i128, modulus: i128) -> TestResult {
@@ -417,7 +417,7 @@ fn quickcheck_modinv() {
 
 #[test]
 fn quickcheck_to_float_equals_i128_cast() {
- let gen = Gen::new(usize::max_value());
+ let gen = Gen::new(usize::MAX);
  let mut qc = QuickCheck::new().gen(gen).tests(1_000_000);
 
  fn to_f32_equals_i128_cast(value: i128) -> bool {

ci/big_serde/src/lib.rs

@@ -155,7 +155,7 @@ fn bad_size_hint<T: Debug + DeserializeOwned + One + PartialEq + Serialize>(
  assert_tokens(&T::one(), &tokens);
 
  tokens[prefix.len()] = Token::Seq {
- len: Some(usize::max_value()),
+ len: Some(usize::MAX),
  };
 
  catch_unwind(|| assert_ser_tokens(&T::one(), &tokens)).unwrap_err();

src/bigint.rs

@@ -8,8 +8,6 @@ use core::fmt;
 use core::hash;
 use core::ops::{Neg, Not};
 use core::str;
-use core::{i128, u128};
-use core::{i64, u64};
 
 use num_integer::{Integer, Roots};
 use num_traits::{ConstZero, Num, One, Pow, Signed, Zero};

src/bigint/convert.rs

@@ -50,7 +50,7 @@ impl ToPrimitive for BigInt {
  let m: u64 = 1 << 63;
  match n.cmp(&m) {
  Less => Some(-(n as i64)),
- Equal => Some(core::i64::MIN),
+ Equal => Some(i64::MIN),
  Greater => None,
  }
  }
@@ -67,7 +67,7 @@ impl ToPrimitive for BigInt {
  let m: u128 = 1 << 127;
  match n.cmp(&m) {
  Less => Some(-(n as i128)),
- Equal => Some(core::i128::MIN),
+ Equal => Some(i128::MIN),
  Greater => None,
  }
  }
@@ -179,7 +179,7 @@ impl From<i64> for BigInt {
  if n >= 0 {
  BigInt::from(n as u64)
  } else {
- let u = core::u64::MAX - (n as u64) + 1;
+ let u = u64::MAX - (n as u64) + 1;
  BigInt {
  sign: Minus,
  data: BigUint::from(u),
@@ -194,7 +194,7 @@ impl From<i128> for BigInt {
  if n >= 0 {
  BigInt::from(n as u128)
  } else {
- let u = core::u128::MAX - (n as u128) + 1;
+ let u = u128::MAX - (n as u128) + 1;
  BigInt {
  sign: Minus,
  data: BigUint::from(u),

src/biguint.rs

@@ -8,7 +8,6 @@ use core::fmt;
 use core::hash;
 use core::mem;
 use core::str;
-use core::{u32, u64, u8};
 
 use num_integer::{Integer, Roots};
 use num_traits::{ConstZero, Num, One, Pow, ToPrimitive, Unsigned, Zero};
@@ -410,7 +409,7 @@ impl Roots for BigUint {
  _ => {
  // Try to guess by scaling down such that it does fit in `f64`.
  // With some (x * 2ⁿᵏ), its nth root ≈ (ⁿ√x * 2ᵏ)
- let extra_bits = bits - (core::f64::MAX_EXP as u64 - 1);
+ let extra_bits = bits - (f64::MAX_EXP as u64 - 1);
  let root_scale = Integer::div_ceil(&extra_bits, &n64);
  let scale = root_scale * n64;
  if scale < bits && bits - scale > n64 {
@@ -458,7 +457,7 @@ impl Roots for BigUint {
  _ => {
  // Try to guess by scaling down such that it does fit in `f64`.
  // With some (x * 2²ᵏ), its sqrt ≈ (√x * 2ᵏ)
- let extra_bits = bits - (core::f64::MAX_EXP as u64 - 1);
+ let extra_bits = bits - (f64::MAX_EXP as u64 - 1);
  let root_scale = (extra_bits + 1) / 2;
  let scale = root_scale * 2;
  (self >> scale).sqrt() << root_scale
@@ -499,7 +498,7 @@ impl Roots for BigUint {
  _ => {
  // Try to guess by scaling down such that it does fit in `f64`.
  // With some (x * 2³ᵏ), its cbrt ≈ (∛x * 2ᵏ)
- let extra_bits = bits - (core::f64::MAX_EXP as u64 - 1);
+ let extra_bits = bits - (f64::MAX_EXP as u64 - 1);
  let root_scale = (extra_bits + 2) / 3;
  let scale = root_scale * 3;
  (self >> scale).cbrt() << root_scale
@@ -1032,9 +1031,7 @@ impl BigUint {
  // Note: we're saturating `digit_index` and `new_len` -- any such case is guaranteed to
  // fail allocation, and that's more consistent than adding our own overflow panics.
  let bits_per_digit = u64::from(big_digit::BITS);
- let digit_index = (bit / bits_per_digit)
- .to_usize()
- .unwrap_or(core::usize::MAX);
+ let digit_index = (bit / bits_per_digit).to_usize().unwrap_or(usize::MAX);
  let bit_mask = (1 as BigDigit) << (bit % bits_per_digit);
  if value {
  if digit_index >= self.data.len() {
@@ -1176,28 +1173,17 @@ cfg_digit!(
 fn test_u32_u128() {
  assert_eq!(u32_from_u128(0u128), (0, 0, 0, 0));
  assert_eq!(
- u32_from_u128(u128::max_value()),
- (
- u32::max_value(),
- u32::max_value(),
- u32::max_value(),
- u32::max_value()
- )
+ u32_from_u128(u128::MAX),
+ (u32::MAX, u32::MAX, u32::MAX, u32::MAX)
  );
 
- assert_eq!(
- u32_from_u128(u32::max_value() as u128),
- (0, 0, 0, u32::max_value())
- );
+ assert_eq!(u32_from_u128(u32::MAX as u128), (0, 0, 0, u32::MAX));
 
- assert_eq!(
- u32_from_u128(u64::max_value() as u128),
- (0, 0, u32::max_value(), u32::max_value())
- );
+ assert_eq!(u32_from_u128(u64::MAX as u128), (0, 0, u32::MAX, u32::MAX));
 
  assert_eq!(
- u32_from_u128((u64::max_value() as u128) + u32::max_value() as u128),
- (0, 1, 0, u32::max_value() - 1)
+ u32_from_u128((u64::MAX as u128) + u32::MAX as u128),
+ (0, 1, 0, u32::MAX - 1)
  );
 
  assert_eq!(u32_from_u128(36_893_488_151_714_070_528), (0, 2, 1, 0));
@@ -1209,11 +1195,11 @@ fn test_u128_u32_roundtrip() {
  let values = vec![
  0u128,
  1u128,
- u64::max_value() as u128 * 3,
- u32::max_value() as u128,
- u64::max_value() as u128,
- (u64::max_value() as u128) + u32::max_value() as u128,
- u128::max_value(),
+ u64::MAX as u128 * 3,
+ u32::MAX as u128,
+ u64::MAX as u128,
+ (u64::MAX as u128) + u32::MAX as u128,
+ u128::MAX,
  ];
 
  for val in &values {

src/biguint/addition.rs

@@ -194,7 +194,7 @@ impl AddAssign<u128> for BigUint {
  cfg_digit!(
  #[inline]
  fn add_assign(&mut self, other: u128) {
- if other <= u128::from(u64::max_value()) {
+ if other <= u128::from(u64::MAX) {
  *self += other as u64
  } else {
  let (a, b, c, d) = super::u32_from_u128(other);

src/biguint/convert.rs

@@ -69,7 +69,7 @@ fn from_inexact_bitwise_digits_le(v: &[u8], bits: u8) -> BigUint {
  let total_bits = (v.len() as u64).saturating_mul(bits.into());
  let big_digits = Integer::div_ceil(&total_bits, &big_digit::BITS.into())
  .to_usize()
- .unwrap_or(core::usize::MAX);
+ .unwrap_or(usize::MAX);
  let mut data = Vec::with_capacity(big_digits);
 
  let mut d = 0;
@@ -245,7 +245,7 @@ impl Num for BigUint {
  b'a'..=b'z' => b - b'a' + 10,
  b'A'..=b'Z' => b - b'A' + 10,
  b'_' => continue,
- _ => core::u8::MAX,
+ _ => u8::MAX,
  };
  if d < radix as u8 {
  v.push(d);
@@ -372,8 +372,8 @@ impl ToPrimitive for BigUint {
  let mantissa = high_bits_to_u64(self);
  let exponent = self.bits() - u64::from(fls(mantissa));
 
- if exponent > core::f32::MAX_EXP as u64 {
- Some(core::f32::INFINITY)
+ if exponent > f32::MAX_EXP as u64 {
+ Some(f32::INFINITY)
  } else {
  Some((mantissa as f32) * 2.0f32.powi(exponent as i32))
  }
@@ -384,8 +384,8 @@ impl ToPrimitive for BigUint {
  let mantissa = high_bits_to_u64(self);
  let exponent = self.bits() - u64::from(fls(mantissa));
 
- if exponent > core::f64::MAX_EXP as u64 {
- Some(core::f64::INFINITY)
+ if exponent > f64::MAX_EXP as u64 {
+ Some(f64::INFINITY)
  } else {
  Some((mantissa as f64) * 2.0f64.powi(exponent as i32))
  }
@@ -607,7 +607,7 @@ pub(super) fn to_bitwise_digits_le(u: &BigUint, bits: u8) -> Vec<u8> {
  let digits_per_big_digit = big_digit::BITS / bits;
  let digits = Integer::div_ceil(&u.bits(), &u64::from(bits))
  .to_usize()
- .unwrap_or(core::usize::MAX);
+ .unwrap_or(usize::MAX);
  let mut res = Vec::with_capacity(digits);
 
  for mut r in u.data[..last_i].iter().cloned() {
@@ -633,7 +633,7 @@ fn to_inexact_bitwise_digits_le(u: &BigUint, bits: u8) -> Vec<u8> {
  let mask: BigDigit = (1 << bits) - 1;
  let digits = Integer::div_ceil(&u.bits(), &u64::from(bits))
  .to_usize()
- .unwrap_or(core::usize::MAX);
+ .unwrap_or(usize::MAX);
  let mut res = Vec::with_capacity(digits);
 
  let mut r = 0;

src/biguint/shift.rs

@@ -58,7 +58,7 @@ fn biguint_shr<T: PrimInt>(n: Cow<'_, BigUint>, shift: T) -> BigUint {
  return n.into_owned();
  }
  let bits = T::from(big_digit::BITS).unwrap();
- let digits = (shift / bits).to_usize().unwrap_or(core::usize::MAX);
+ let digits = (shift / bits).to_usize().unwrap_or(usize::MAX);
  let shift = (shift % bits).to_u8().unwrap();
  biguint_shr2(n, digits, shift)
 }

tests/bigint.rs

@@ -8,9 +8,6 @@ use std::hash::{BuildHasher, Hash, Hasher};
 use std::iter::repeat;
 use std::ops::Neg;
 use std::{f32, f64};
-use std::{i128, u128};
-use std::{i16, i32, i64, i8, isize};
-use std::{u16, u32, u64, u8, usize};
 
 use num_integer::Integer;
 use num_traits::{

tests/bigint_bitwise.rs

@@ -1,6 +1,5 @@
 use num_bigint::{BigInt, Sign, ToBigInt};
 use num_traits::ToPrimitive;
-use std::{i32, i64, u32};
 
 enum ValueVec {
  N,