Remove From [u8; n] impl for uint types (#859)

pgherveou · athei · ordian · web-flow · commit 0db43ee6a258 · 2024-09-10T12:17:05.000+02:00
* update uint and deps

* Fix uppercase

* Apply suggestions from code review

Co-authored-by: Alexander Theißen &lt;alex.theissen@me.com&gt;

* Update changelogs

* Apply suggestions from code review

* Apply suggestions from code review

---------

Co-authored-by: Alexander Theißen &lt;alex.theissen@me.com&gt;
Co-authored-by: ordian &lt;write@reusable.software&gt;
diff --git a/ethereum-types/CHANGELOG.md b/ethereum-types/CHANGELOG.md
@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog].
 [Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
 
 ## [Unreleased]
+### Breaking
+- Updated `uint` to 0.10. [#859](https://github.com/paritytech/parity-common/pull/859)
 
 ## [0.14.1] - 2022-11-29
 - Added `if_ethbloom` conditional macro. [#682](https://github.com/paritytech/parity-common/pull/682)
diff --git a/ethereum-types/src/hash.rs b/ethereum-types/src/hash.rs
@@ -74,12 +74,12 @@ macro_rules! impl_uint_conversions {
 
 			fn from_uint(value: &$uint) -> Self {
 				let mut ret = $hash::zero();
-				value.to_big_endian(ret.as_bytes_mut());
+				value.write_as_big_endian(ret.as_bytes_mut());
 				ret
 			}
 
 			fn into_uint(&self) -> $uint {
-				$uint::from(self.as_ref() as &[u8])
+				$uint::from_big_endian(self.as_ref() as &[u8])
 			}
 		}
 	};
diff --git a/ethereum-types/src/uint.rs b/ethereum-types/src/uint.rs
@@ -102,8 +102,8 @@ mod tests {
 	#[test]
 	fn fixed_arrays_roundtrip() {
 		let raw: U256 = "7094875209347850239487502394881".into();
-		let array: [u8; 32] = raw.into();
-		let new_raw = array.into();
+		let array: [u8; 32] = raw.to_big_endian();
+		let new_raw = U256::from_big_endian(&array);
 
 		assert_eq!(raw, new_raw);
 	}
diff --git a/primitive-types/CHANGELOG.md b/primitive-types/CHANGELOG.md
@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog].
 [Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
 
 ## [Unreleased]
+### Breaking
+- Updated `uint` to 0.10. [#859](https://github.com/paritytech/parity-common/pull/859)
 
 ## [0.12.2] - 2023-10-10
 - Added `schemars` support via `json-schema` feature. [#785](https://github.com/paritytech/parity-common/pull/785)
diff --git a/primitive-types/impls/codec/src/lib.rs b/primitive-types/impls/codec/src/lib.rs
@@ -19,8 +19,7 @@ macro_rules! impl_uint_codec {
 	($name: ident, $len: expr) => {
 		impl $crate::codec::Encode for $name {
 			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-				let mut bytes = [0u8; $len * 8];
-				self.to_little_endian(&mut bytes);
+				let bytes = self.to_little_endian();
 				bytes.using_encoded(f)
 			}
 		}
diff --git a/primitive-types/impls/rlp/src/lib.rs b/primitive-types/impls/rlp/src/lib.rs
@@ -23,8 +23,7 @@ macro_rules! impl_uint_rlp {
 		impl $crate::rlp::Encodable for $name {
 			fn rlp_append(&self, s: &mut $crate::rlp::RlpStream) {
 				let leading_empty_bytes = $size * 8 - (self.bits() + 7) / 8;
-				let mut buffer = [0u8; $size * 8];
-				self.to_big_endian(&mut buffer);
+				let buffer = self.to_big_endian();
 				s.encoder().encode_value(&buffer[leading_empty_bytes..]);
 			}
 		}
@@ -35,7 +34,7 @@ macro_rules! impl_uint_rlp {
 					if !bytes.is_empty() && bytes[0] == 0 {
 						Err($crate::rlp::DecoderError::RlpInvalidIndirection)
 					} else if bytes.len() <= $size * 8 {
-						Ok($name::from(bytes))
+						Ok($name::from_big_endian(bytes))
 					} else {
 						Err($crate::rlp::DecoderError::RlpIsTooBig)
 					}
diff --git a/primitive-types/impls/serde/CHANGELOG.md b/primitive-types/impls/serde/CHANGELOG.md
@@ -4,6 +4,10 @@ The format is based on [Keep a Changelog].
 
 [Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
 
+## [Unreleased]
+### Breaking
+- Updated `uint` to 0.10. [#859](https://github.com/paritytech/parity-common/pull/859)
+
 ## [0.4.0] - 2022-09-02
 - Support deserializing H256 et al from bytes or sequences of bytes, too. [#668](https://github.com/paritytech/parity-common/pull/668)
 - Support deserializing H256 et al from newtype structs containing anything compatible, too. [#672](https://github.com/paritytech/parity-common/pull/672)
diff --git a/primitive-types/impls/serde/src/lib.rs b/primitive-types/impls/serde/src/lib.rs
@@ -32,8 +32,7 @@ macro_rules! impl_uint_serde {
 				S: $crate::serde::Serializer,
 			{
 				let mut slice = [0u8; 2 + 2 * $len * 8];
-				let mut bytes = [0u8; $len * 8];
-				self.to_big_endian(&mut bytes);
+				let bytes = self.to_big_endian();
 				$crate::serialize::serialize_uint(&mut slice, &bytes, serializer)
 			}
 		}
@@ -48,7 +47,7 @@ macro_rules! impl_uint_serde {
 					deserializer,
 					$crate::serialize::ExpectedLen::Between(0, &mut bytes),
 				)?;
-				Ok(bytes[0..wrote].into())
+				Ok(Self::from_big_endian(&bytes[0..wrote]))
 			}
 		}
 	};
diff --git a/rlp/tests/tests.rs b/rlp/tests/tests.rs
@@ -226,7 +226,7 @@ fn encode_u256() {
 		ETestPair::from((U256::from(0x0100_0000_u64), hex!("8401000000"))),
 		ETestPair::from((U256::from(0xffff_ffff_u64), hex!("84ffffffff"))),
 		ETestPair::from((
-			hex!("  8090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0").into(),
+			U256::from_big_endian(&hex!("  8090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0")),
 			hex!("a08090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0"),
 		)),
 	];
@@ -482,7 +482,7 @@ fn decode_untrusted_u256() {
 		DTestPair::from((U256::from(0x0100_0000_u64), hex!("8401000000"))),
 		DTestPair::from((U256::from(0xffff_ffff_u64), hex!("84ffffffff"))),
 		DTestPair::from((
-			hex!("  8090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0").into(),
+			U256::from_big_endian(&hex!("  8090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0")),
 			hex!("a08090a0b0c0d0e0f00910203040506077000000000000000100000000000012f0"),
 		)),
 	];
diff --git a/uint/CHANGELOG.md b/uint/CHANGELOG.md
@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog].
 [Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
 
 ## [Unreleased]
+### Breaking
+- Removed From<[u8; n]> conversions, renamed `to_big_endian` / `to_little_endian` to write_as_*, and made them return byte arrays. [#859](https://github.com/paritytech/parity-common/pull/859)
 
 ## [0.9.5] - 2022-11-29
 - Implemented bitwise assign traits. [#690](https://github.com/paritytech/parity-common/pull/690)
diff --git a/uint/benches/bigint.rs b/uint/benches/bigint.rs
@@ -78,8 +78,7 @@ criterion_group!(
 criterion_main!(bigint);
 
 fn to_biguint(x: U256) -> BigUint {
-	let mut bytes = [0u8; 32];
-	x.to_little_endian(&mut bytes);
+	let bytes = x.to_little_endian();
 	BigUint::from_bytes_le(&bytes)
 }
 
@@ -662,8 +661,8 @@ fn from_fixed_array(c: &mut Criterion) {
 		[255, 0, 0, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 0, 0, 213, 0, 0, 0, 0, 0, 0];
 	c.bench_function("from_fixed_array", move |b| {
 		b.iter(|| {
-			let _: U512 = black_box(black_box(ary512).into());
-			let _: U256 = black_box(black_box(ary256).into());
+			let _: U512 = black_box(U512::from_big_endian(black_box(&ary512)));
+			let _: U256 = black_box(U256::from_big_endian(black_box(&ary256)));
 		})
 	});
 }
diff --git a/uint/src/uint.rs b/uint/src/uint.rs
@@ -743,19 +743,34 @@ macro_rules! construct_uint {
 				(arr[index / 8] >> (((index % 8)) * 8)) as u8
 			}
 
+			/// Convert to big-endian bytes.
+			#[inline]
+			pub fn to_big_endian(&self)  -> [u8; $n_words * 8] {
+				let mut bytes = [0u8; $n_words * 8];
+				self.write_as_big_endian(&mut bytes);
+				bytes
+			}
+
 			/// Write to the slice in big-endian format.
 			#[inline]
-			pub fn to_big_endian(&self, bytes: &mut [u8]) {
+			pub fn write_as_big_endian(&self, bytes: &mut [u8]) {
 				use $crate::byteorder::{ByteOrder, BigEndian};
 				debug_assert!($n_words * 8 == bytes.len());
 				for i in 0..$n_words {
 					BigEndian::write_u64(&mut bytes[8 * i..], self.0[$n_words - i - 1]);
 				}
 			}
 
-			/// Write to the slice in little-endian format.
+			/// Convert to little-endian bytes.
 			#[inline]
-			pub fn to_little_endian(&self, bytes: &mut [u8]) {
+			pub fn to_little_endian(&self) -> [u8; $n_words * 8] {
+				let mut bytes = [0u8; $n_words * 8];
+				self.write_as_little_endian(&mut bytes);
+				bytes
+			}
+
+			#[inline]
+			pub fn write_as_little_endian(&self, bytes: &mut [u8]) {
 				use $crate::byteorder::{ByteOrder, LittleEndian};
 				debug_assert!($n_words * 8 == bytes.len());
 				for i in 0..$n_words {
@@ -1307,26 +1322,6 @@ macro_rules! construct_uint {
 			}
 		}
 
-		impl $crate::core_::convert::From<$name> for [u8; $n_words * 8] {
-			fn from(number: $name) -> Self {
-				let mut arr = [0u8; $n_words * 8];
-				number.to_big_endian(&mut arr);
-				arr
-			}
-		}
-
-		impl $crate::core_::convert::From<[u8; $n_words * 8]> for $name {
-			fn from(bytes: [u8; $n_words * 8]) -> Self {
-				Self::from(&bytes)
-			}
-		}
-
-		impl<'a> $crate::core_::convert::From<&'a [u8; $n_words * 8]> for $name {
-			fn from(bytes: &[u8; $n_words * 8]) -> Self {
-				Self::from(&bytes[..])
-			}
-		}
-
 		impl $crate::core_::default::Default for $name {
 			fn default() -> Self {
 				$name::zero()
@@ -1360,13 +1355,6 @@ macro_rules! construct_uint {
 		$crate::impl_map_from!($name, i32, i64);
 		$crate::impl_map_from!($name, isize, i64);
 
-		// Converts from big endian representation.
-		impl<'a> $crate::core_::convert::From<&'a [u8]> for $name {
-			fn from(bytes: &[u8]) -> $name {
-				Self::from_big_endian(bytes)
-			}
-		}
-
 		$crate::impl_try_from_for_primitive!($name, u8);
 		$crate::impl_try_from_for_primitive!($name, u16);
 		$crate::impl_try_from_for_primitive!($name, u32);
@@ -1736,8 +1724,7 @@ macro_rules! construct_uint {
 					$crate::hex::decode_to_slice(encoded, out).map_err(Self::Err::from)?;
 				}
 
-				let bytes_ref: &[u8] = &bytes;
-				Ok(From::from(bytes_ref))
+				Ok(Self::from_big_endian(&bytes))
 			}
 		}
 
@@ -1787,7 +1774,7 @@ macro_rules! impl_quickcheck_arbitrary_for_uint {
 					}
 				});
 
-				res.as_ref().into()
+				Self::from_big_endian(res.as_ref())
 			}
 		}
 	};
@@ -1809,7 +1796,7 @@ macro_rules! impl_arbitrary_for_uint {
 			fn arbitrary(u: &mut $crate::arbitrary::Unstructured<'_>) -> $crate::arbitrary::Result<Self> {
 				let mut res = [0u8; $n_bytes];
 				u.fill_buffer(&mut res)?;
-				Ok(Self::from(res))
+				Ok(Self::from_big_endian(&res))
 			}
 		}
 	};
diff --git a/uint/tests/uint_tests.rs b/uint/tests/uint_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -74,12 +74,12 @@ macro_rules! impl_uint_conversions {`
`74`	`74`
`75`	`75`	`fn from_uint(value: &$uint) -> Self {`
`76`	`76`	`let mut ret = $hash::zero();`
`77`		`- value.to_big_endian(ret.as_bytes_mut());`
	`77`	`+ value.write_as_big_endian(ret.as_bytes_mut());`
`78`	`78`	`ret`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`fn into_uint(&self) -> $uint {`
`82`		`- $uint::from(self.as_ref() as &[u8])`
	`82`	`+ $uint::from_big_endian(self.as_ref() as &[u8])`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`	`};`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,7 @@ macro_rules! impl_uint_codec {`
`19`	`19`	`($name: ident, $len: expr) => {`
`20`	`20`	`impl $crate::codec::Encode for $name {`
`21`	`21`	`fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {`
`22`		`- let mut bytes = [0u8; $len * 8];`
`23`		`- self.to_little_endian(&mut bytes);`
	`22`	`+ let bytes = self.to_little_endian();`
`24`	`23`	`bytes.using_encoded(f)`
`25`	`24`	`}`
`26`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ macro_rules! impl_uint_rlp {`
`23`	`23`	`impl $crate::rlp::Encodable for $name {`
`24`	`24`	`fn rlp_append(&self, s: &mut $crate::rlp::RlpStream) {`
`25`	`25`	`let leading_empty_bytes = $size * 8 - (self.bits() + 7) / 8;`
`26`		`- let mut buffer = [0u8; $size * 8];`
`27`		`- self.to_big_endian(&mut buffer);`
	`26`	`+ let buffer = self.to_big_endian();`
`28`	`27`	`s.encoder().encode_value(&buffer[leading_empty_bytes..]);`
`29`	`28`	`}`
`30`	`29`	`}`
`@@ -35,7 +34,7 @@ macro_rules! impl_uint_rlp {`
`35`	`34`	`if !bytes.is_empty() && bytes[0] == 0 {`
`36`	`35`	`Err($crate::rlp::DecoderError::RlpInvalidIndirection)`
`37`	`36`	`} else if bytes.len() <= $size * 8 {`
`38`		`- Ok($name::from(bytes))`
	`37`	`+ Ok($name::from_big_endian(bytes))`
`39`	`38`	`} else {`
`40`	`39`	`Err($crate::rlp::DecoderError::RlpIsTooBig)`
`41`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,7 @@ macro_rules! impl_uint_serde {`
`32`	`32`	`S: $crate::serde::Serializer,`
`33`	`33`	`{`
`34`	`34`	`let mut slice = [0u8; 2 + 2 * $len * 8];`
`35`		`- let mut bytes = [0u8; $len * 8];`
`36`		`- self.to_big_endian(&mut bytes);`
	`35`	`+ let bytes = self.to_big_endian();`
`37`	`36`	`$crate::serialize::serialize_uint(&mut slice, &bytes, serializer)`
`38`	`37`	`}`
`39`	`38`	`}`
`@@ -48,7 +47,7 @@ macro_rules! impl_uint_serde {`
`48`	`47`	`deserializer,`
`49`	`48`	`$crate::serialize::ExpectedLen::Between(0, &mut bytes),`
`50`	`49`	`)?;`
`51`		`- Ok(bytes[0..wrote].into())`
	`50`	`+ Ok(Self::from_big_endian(&bytes[0..wrote]))`
`52`	`51`	`}`
`53`	`52`	`}`
`54`	`53`	`};`