uint: make max_value const, test, simplify

uint/CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog].
 
 ## [Unreleased]
 - Make `one` const. [#650](https://github.com/paritytech/parity-common/pull/650)
+- Make `max_value` const and deprecate it. [#652](https://github.com/paritytech/parity-common/pull/652)
 
 ## [0.9.3] - 2022-02-04
 - Simplified and faster `div_mod`. [#478](https://github.com/paritytech/parity-common/pull/478)

uint/benches/bigint.rs

@@ -142,7 +142,7 @@ fn u256_sub(c: &mut Criterion) {
 					black_box(x.overflowing_sub(y).0)
 				})
 			},
-			vec![(U256::max_value(), 1u64), (U256::from(3), 2)],
+			vec![(U256::MAX, 1u64), (U256::from(3), 2)],
 		),
 	);
 }
@@ -159,7 +159,7 @@ fn u256_mul(c: &mut Criterion) {
 				})
 			},
 			vec![
-				(U256::max_value(), 1u64),
+				(U256::MAX, 1u64),
 				(U256::from(3), u64::max_value()),
 				(U256::from_dec_str("21674844646682989462120101885968193938394323990565507610662749").unwrap(), 173),
 			],
@@ -179,7 +179,7 @@ fn u512_div_mod(c: &mut Criterion) {
 				})
 			},
 			vec![
-				(U512::max_value(), U512::from(1u64)),
+				(U512::MAX, U512::from(1u64)),
 				(U512::from(u64::max_value()), U512::from(u32::max_value())),
 				(U512::from(u64::max_value()), U512::from(u64::max_value() - 1)),
 				(U512::from(u64::max_value()), U512::from(u64::max_value() - 1)),
@@ -240,7 +240,7 @@ fn u256_rem(c: &mut Criterion) {
 			"",
 			|b, (x, y)| b.iter(|| black_box(x % y)),
 			vec![
-				(U256::max_value(), U256::from(1u64)),
+				(U256::MAX, U256::from(1u64)),
 				(U256::from(u64::max_value()), U256::from(u64::from(u32::max_value()) + 1)),
 				(
 					U256([12767554894655550452, 16333049135534778834, 140317443000293558, 598963]),

uint/src/uint.rs

@@ -800,13 +800,10 @@ macro_rules! construct_uint {
 			}
 
 			/// The maximum value which can be inhabited by this type.
+			#[deprecated(note = "replaced by the `MAX` associated constant on this type")]
 			#[inline]
-			pub fn max_value() -> Self {
-				let mut result = [0; $n_words];
-				for i in 0..$n_words {
-					result[i] = u64::max_value();
-				}
-				$name(result)
+			pub const fn max_value() -> Self {
+				Self::MAX
 			}
 
 			fn full_shl(self, shift: u32) -> [u64; $n_words + 1] {
@@ -1071,10 +1068,10 @@ macro_rules! construct_uint {
 				)
 			}
 
-			/// Addition which saturates at the maximum value (Self::max_value()).
+			/// Addition which saturates at the maximum value (Self::MAX).
 			pub fn saturating_add(self, other: $name) -> $name {
 				match self.overflowing_add(other) {
-					(_, true) => $name::max_value(),
+					(_, true) => $name::MAX,
 					(val, false) => val,
 				}
 			}
@@ -1124,7 +1121,7 @@ macro_rules! construct_uint {
 			/// Multiplication which saturates at the maximum value..
 			pub fn saturating_mul(self, other: $name) -> $name {
 				match self.overflowing_mul(other) {
-					(_, true) => $name::max_value(),
+					(_, true) => $name::MAX,
 					(val, false) => val,
 				}
 			}

uint/tests/uint_tests.rs

@@ -48,6 +48,27 @@ fn const_matching_works() {
 	}
 }
 
+#[test]
+fn max() {
+	let max = U256::MAX;
+	assert_eq!(max.0, [0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF]);
+
+	let max = U512::MAX;
+	assert_eq!(
+		max.0,
+		[
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF
+		]
+	);
+}
+
 #[test]
 fn one() {
 	let one = U256::one();
@@ -63,6 +84,28 @@ fn one() {
 	assert_eq!(any * U512::one(), any);
 }
 
+#[test]
+#[allow(deprecated)]
+fn max_value() {
+	let max = U256::max_value();
+	assert_eq!(max.0, [0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF]);
+
+	let max = U512::max_value();
+	assert_eq!(
+		max.0,
+		[
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF,
+			0xFFFFFFFFFFFFFFFF
+		]
+	);
+}
+
 #[test]
 fn u128_conversions() {
 	let mut a = U256::from(u128::max_value());
@@ -85,7 +128,7 @@ fn uint256_checked_ops() {
 	assert_eq!(U256::from(10).checked_pow(U256::from(3)), Some(U256::from(1000)));
 	assert_eq!(U256::from(10).checked_pow(U256::from(20)), Some(U256::exp10(20)));
 	assert_eq!(U256::from(2).checked_pow(U256::from(0x100)), None);
-	assert_eq!(U256::max_value().checked_pow(U256::from(2)), None);
+	assert_eq!(U256::MAX.checked_pow(U256::from(2)), None);
 
 	assert_eq!(a.checked_add(b), None);
 	assert_eq!(a.checked_add(a), Some(20.into()));