saymrwulf/risc0-curve25519-dalek-source
1
0
Fork 0
mirror of https://github.com/saymrwulf/risc0-curve25519-dalek-source.git synced 2026-09-07 20:30:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Address new nightly clippy unnecessary qualifications (#639)

Browse source
This commit is contained in:
pinkforest(she/her) 2024-03-08 10:58:20 +11:00 committed by GitHub
parent 31ccb67050
commit 858c4ca8ae
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
15 changed files with 52 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
curve25519-dalek/src/backend/mod.rs
View file

@ -87,24 +87,24 @@ where
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => BackendKind::Avx2 =>
self::vector::scalar_mul::pippenger::spec_avx2::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points), vector::scalar_mul::pippenger::spec_avx2::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => BackendKind::Avx512 =>
self::vector::scalar_mul::pippenger::spec_avx512ifma_avx512vl::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points), vector::scalar_mul::pippenger::spec_avx512ifma_avx512vl::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
BackendKind::Serial => BackendKind::Serial =>
self::serial::scalar_mul::pippenger::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points), serial::scalar_mul::pippenger::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
} }
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub(crate) enum VartimePrecomputedStraus { pub(crate) enum VartimePrecomputedStraus {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
Avx2(self::vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus), Avx2(vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus),
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
Avx512ifma( Avx512ifma(
self::vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus, vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus,
), ),
Scalar(self::serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus), Scalar(serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus),
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
@ -119,12 +119,12 @@ impl VartimePrecomputedStraus {
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => BackendKind::Avx2 =>
VartimePrecomputedStraus::Avx2(self::vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus::new(static_points)), VartimePrecomputedStraus::Avx2(vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus::new(static_points)),
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => BackendKind::Avx512 =>
VartimePrecomputedStraus::Avx512ifma(self::vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus::new(static_points)), VartimePrecomputedStraus::Avx512ifma(vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus::new(static_points)),
BackendKind::Serial => BackendKind::Serial =>
VartimePrecomputedStraus::Scalar(self::serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus::new(static_points)) VartimePrecomputedStraus::Scalar(serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus::new(static_points))
} }
} }
@ -179,19 +179,16 @@ where
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => { BackendKind::Avx2 => {
self::vector::scalar_mul::straus::spec_avx2::Straus::multiscalar_mul::<I, J>( vector::scalar_mul::straus::spec_avx2::Straus::multiscalar_mul::<I, J>(scalars, points)
scalars, points,
)
} }
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => { BackendKind::Avx512 => {
self::vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::multiscalar_mul::< vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::multiscalar_mul::<I, J>(
I, scalars, points,
J, )
>(scalars, points)
} }
BackendKind::Serial => { BackendKind::Serial => {
self::serial::scalar_mul::straus::Straus::multiscalar_mul::<I, J>(scalars, points) serial::scalar_mul::straus::Straus::multiscalar_mul::<I, J>(scalars, points)
} }
} }
} }
@ -209,21 +206,19 @@ where
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => { BackendKind::Avx2 => {
self::vector::scalar_mul::straus::spec_avx2::Straus::optional_multiscalar_mul::<I, J>( vector::scalar_mul::straus::spec_avx2::Straus::optional_multiscalar_mul::<I, J>(
scalars, points, scalars, points,
) )
} }
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => { BackendKind::Avx512 => {
self::vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::optional_multiscalar_mul::< vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::optional_multiscalar_mul::<
I, I,
J, J,
>(scalars, points) >(scalars, points)
} }
BackendKind::Serial => { BackendKind::Serial => {
self::serial::scalar_mul::straus::Straus::optional_multiscalar_mul::<I, J>( serial::scalar_mul::straus::Straus::optional_multiscalar_mul::<I, J>(scalars, points)
scalars, points,
)
} }
} }
} }
@ -232,12 +227,12 @@ where
pub fn variable_base_mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint { pub fn variable_base_mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint {
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => self::vector::scalar_mul::variable_base::spec_avx2::mul(point, scalar), BackendKind::Avx2 => vector::scalar_mul::variable_base::spec_avx2::mul(point, scalar),
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => { BackendKind::Avx512 => {
self::vector::scalar_mul::variable_base::spec_avx512ifma_avx512vl::mul(point, scalar) vector::scalar_mul::variable_base::spec_avx512ifma_avx512vl::mul(point, scalar)
} }
BackendKind::Serial => self::serial::scalar_mul::variable_base::mul(point, scalar), BackendKind::Serial => serial::scalar_mul::variable_base::mul(point, scalar),
} }
} }
@ -246,11 +241,11 @@ pub fn variable_base_mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint
pub fn vartime_double_base_mul(a: &Scalar, A: &EdwardsPoint, b: &Scalar) -> EdwardsPoint { pub fn vartime_double_base_mul(a: &Scalar, A: &EdwardsPoint, b: &Scalar) -> EdwardsPoint {
match get_selected_backend() { match get_selected_backend() {
#[cfg(curve25519_dalek_backend = "simd")] #[cfg(curve25519_dalek_backend = "simd")]
BackendKind::Avx2 => self::vector::scalar_mul::vartime_double_base::spec_avx2::mul(a, A, b), BackendKind::Avx2 => vector::scalar_mul::vartime_double_base::spec_avx2::mul(a, A, b),
#[cfg(all(curve25519_dalek_backend = "simd", nightly))] #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
BackendKind::Avx512 => { BackendKind::Avx512 => {
self::vector::scalar_mul::vartime_double_base::spec_avx512ifma_avx512vl::mul(a, A, b) vector::scalar_mul::vartime_double_base::spec_avx512ifma_avx512vl::mul(a, A, b)
} }
BackendKind::Serial => self::serial::scalar_mul::vartime_double_base::mul(a, A, b), BackendKind::Serial => serial::scalar_mul::vartime_double_base::mul(a, A, b),
} }
} }

8
curve25519-dalek/src/backend/serial/curve_models/mod.rs
View file

@ -527,7 +527,7 @@ impl<'a> Neg for &'a AffineNielsPoint {
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
impl Debug for ProjectivePoint { impl Debug for ProjectivePoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!( write!(
f, f,
"ProjectivePoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?}\n}}", "ProjectivePoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?}\n}}",
@ -537,7 +537,7 @@ impl Debug for ProjectivePoint {
} }
impl Debug for CompletedPoint { impl Debug for CompletedPoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!( write!(
f, f,
"CompletedPoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?},\n\tT: {:?}\n}}", "CompletedPoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?},\n\tT: {:?}\n}}",
@ -547,7 +547,7 @@ impl Debug for CompletedPoint {
} }
impl Debug for AffineNielsPoint { impl Debug for AffineNielsPoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!( write!(
f, f,
"AffineNielsPoint{{\n\ty_plus_x: {:?},\n\ty_minus_x: {:?},\n\txy2d: {:?}\n}}", "AffineNielsPoint{{\n\ty_plus_x: {:?},\n\ty_minus_x: {:?},\n\txy2d: {:?}\n}}",
@ -557,7 +557,7 @@ impl Debug for AffineNielsPoint {
} }
impl Debug for ProjectiveNielsPoint { impl Debug for ProjectiveNielsPoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "ProjectiveNielsPoint{{\n\tY_plus_X: {:?},\n\tY_minus_X: {:?},\n\tZ: {:?},\n\tT2d: {:?}\n}}", write!(f, "ProjectiveNielsPoint{{\n\tY_plus_X: {:?},\n\tY_minus_X: {:?},\n\tZ: {:?},\n\tT2d: {:?}\n}}",
&self.Y_plus_X, &self.Y_minus_X, &self.Z, &self.T2d) &self.Y_plus_X, &self.Y_minus_X, &self.Z, &self.T2d)
} }

2
curve25519-dalek/src/backend/serial/fiat_u32/field.rs
View file

@ -58,7 +58,7 @@ use fiat_crypto::curve25519_32::*;
pub struct FieldElement2625(pub(crate) fiat_25519_tight_field_element); pub struct FieldElement2625(pub(crate) fiat_25519_tight_field_element);
impl Debug for FieldElement2625 { impl Debug for FieldElement2625 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "FieldElement2625({:?})", &(self.0).0[..]) write!(f, "FieldElement2625({:?})", &(self.0).0[..])
} }
} }

2
curve25519-dalek/src/backend/serial/fiat_u64/field.rs
View file

@ -47,7 +47,7 @@ use fiat_crypto::curve25519_64::*;
pub struct FieldElement51(pub(crate) fiat_25519_tight_field_element); pub struct FieldElement51(pub(crate) fiat_25519_tight_field_element);
impl Debug for FieldElement51 { impl Debug for FieldElement51 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "FieldElement51({:?})", &(self.0).0[..]) write!(f, "FieldElement51({:?})", &(self.0).0[..])
} }
} }

2
curve25519-dalek/src/backend/serial/u32/field.rs
View file

@ -54,7 +54,7 @@ use zeroize::Zeroize;
pub struct FieldElement2625(pub(crate) [u32; 10]); pub struct FieldElement2625(pub(crate) [u32; 10]);
impl Debug for FieldElement2625 { impl Debug for FieldElement2625 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "FieldElement2625({:?})", &self.0[..]) write!(f, "FieldElement2625({:?})", &self.0[..])
} }
} }

2
curve25519-dalek/src/backend/serial/u32/scalar.rs
View file

@ -24,7 +24,7 @@ use crate::constants;
pub struct Scalar29(pub [u32; 9]); pub struct Scalar29(pub [u32; 9]);
impl Debug for Scalar29 { impl Debug for Scalar29 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Scalar29: {:?}", &self.0[..]) write!(f, "Scalar29: {:?}", &self.0[..])
} }
} }

2
curve25519-dalek/src/backend/serial/u64/field.rs
View file

@ -43,7 +43,7 @@ use zeroize::Zeroize;
pub struct FieldElement51(pub(crate) [u64; 5]); pub struct FieldElement51(pub(crate) [u64; 5]);
impl Debug for FieldElement51 { impl Debug for FieldElement51 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "FieldElement51({:?})", &self.0[..]) write!(f, "FieldElement51({:?})", &self.0[..])
} }
} }

2
curve25519-dalek/src/backend/serial/u64/scalar.rs
View file

@ -25,7 +25,7 @@ use crate::constants;
pub struct Scalar52(pub [u64; 5]); pub struct Scalar52(pub [u64; 5]);
impl Debug for Scalar52 { impl Debug for Scalar52 {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Scalar52: {:?}", &self.0[..]) write!(f, "Scalar52: {:?}", &self.0[..])
} }
} }

10
curve25519-dalek/src/edwards.rs
View file

@ -171,7 +171,7 @@ impl ConstantTimeEq for CompressedEdwardsY {
} }
impl Debug for CompressedEdwardsY { impl Debug for CompressedEdwardsY {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "CompressedEdwardsY: {:?}", self.as_bytes()) write!(f, "CompressedEdwardsY: {:?}", self.as_bytes())
} }
} }
@ -302,7 +302,7 @@ impl<'de> Deserialize<'de> for EdwardsPoint {
impl<'de> Visitor<'de> for EdwardsPointVisitor { impl<'de> Visitor<'de> for EdwardsPointVisitor {
type Value = EdwardsPoint; type Value = EdwardsPoint;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("a valid point in Edwards y + sign format") formatter.write_str("a valid point in Edwards y + sign format")
} }
@ -338,7 +338,7 @@ impl<'de> Deserialize<'de> for CompressedEdwardsY {
impl<'de> Visitor<'de> for CompressedEdwardsYVisitor { impl<'de> Visitor<'de> for CompressedEdwardsYVisitor {
type Value = CompressedEdwardsY; type Value = CompressedEdwardsY;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("32 bytes of data") formatter.write_str("32 bytes of data")
} }
@ -1053,7 +1053,7 @@ macro_rules! impl_basepoint_table {
} }
impl Debug for $name { impl Debug for $name {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{:?}([\n", stringify!($name))?; write!(f, "{:?}([\n", stringify!($name))?;
for i in 0..32 { for i in 0..32 {
write!(f, "\t{:?},\n", &self.0[i])?; write!(f, "\t{:?},\n", &self.0[i])?;
@ -1264,7 +1264,7 @@ impl EdwardsPoint {
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
impl Debug for EdwardsPoint { impl Debug for EdwardsPoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!( write!(
f, f,
"EdwardsPoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?},\n\tT: {:?}\n}}", "EdwardsPoint{{\n\tX: {:?},\n\tY: {:?},\n\tZ: {:?},\n\tT: {:?}\n}}",

8
curve25519-dalek/src/ristretto.rs
View file

@ -407,7 +407,7 @@ impl<'de> Deserialize<'de> for RistrettoPoint {
impl<'de> Visitor<'de> for RistrettoPointVisitor { impl<'de> Visitor<'de> for RistrettoPointVisitor {
type Value = RistrettoPoint; type Value = RistrettoPoint;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("a valid point in Ristretto format") formatter.write_str("a valid point in Ristretto format")
} }
@ -443,7 +443,7 @@ impl<'de> Deserialize<'de> for CompressedRistretto {
impl<'de> Visitor<'de> for CompressedRistrettoVisitor { impl<'de> Visitor<'de> for CompressedRistrettoVisitor {
type Value = CompressedRistretto; type Value = CompressedRistretto;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("32 bytes of data") formatter.write_str("32 bytes of data")
} }
@ -1155,13 +1155,13 @@ impl ConditionallySelectable for RistrettoPoint {
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
impl Debug for CompressedRistretto { impl Debug for CompressedRistretto {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "CompressedRistretto: {:?}", self.as_bytes()) write!(f, "CompressedRistretto: {:?}", self.as_bytes())
} }
} }
impl Debug for RistrettoPoint { impl Debug for RistrettoPoint {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let coset = self.coset4(); let coset = self.coset4();
write!( write!(
f, f,

6
curve25519-dalek/src/scalar.rs
View file

@ -285,7 +285,7 @@ impl Scalar {
} }
impl Debug for Scalar { impl Debug for Scalar {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Scalar{{\n\tbytes: {:?},\n}}", &self.bytes) write!(f, "Scalar{{\n\tbytes: {:?},\n}}", &self.bytes)
} }
} }
@ -430,7 +430,7 @@ impl<'de> Deserialize<'de> for Scalar {
impl<'de> Visitor<'de> for ScalarVisitor { impl<'de> Visitor<'de> for ScalarVisitor {
type Value = Scalar; type Value = Scalar;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str( formatter.write_str(
"a sequence of 32 bytes whose little-endian interpretation is less than the \ "a sequence of 32 bytes whose little-endian interpretation is less than the \
basepoint order ℓ", basepoint order ℓ",
@ -831,7 +831,7 @@ impl Scalar {
} }
#[cfg(feature = "zeroize")] #[cfg(feature = "zeroize")]
zeroize::Zeroize::zeroize(&mut scratch); Zeroize::zeroize(&mut scratch);
ret ret
} }

6
curve25519-dalek/src/window.rs
View file

@ -83,7 +83,7 @@ macro_rules! impl_lookup_table {
} }
impl<T: Debug> Debug for $name<T> { impl<T: Debug> Debug for $name<T> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{:?}(", stringify!($name))?; write!(f, "{:?}(", stringify!($name))?;
for x in self.0.iter() { for x in self.0.iter() {
@ -193,7 +193,7 @@ impl<T: Copy> NafLookupTable5<T> {
} }
impl<T: Debug> Debug for NafLookupTable5<T> { impl<T: Debug> Debug for NafLookupTable5<T> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "NafLookupTable5({:?})", self.0) write!(f, "NafLookupTable5({:?})", self.0)
} }
} }
@ -240,7 +240,7 @@ impl<T: Copy> NafLookupTable8<T> {
#[cfg(any(feature = "precomputed-tables", feature = "alloc"))] #[cfg(any(feature = "precomputed-tables", feature = "alloc"))]
impl<T: Debug> Debug for NafLookupTable8<T> { impl<T: Debug> Debug for NafLookupTable8<T> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
writeln!(f, "NafLookupTable8([")?; writeln!(f, "NafLookupTable8([")?;
for i in 0..64 { for i in 0..64 {
writeln!(f, "\t{:?},", &self.0[i])?; writeln!(f, "\t{:?},", &self.0[i])?;

2
ed25519-dalek/src/signature.rs
View file

@ -57,7 +57,7 @@ impl Clone for InternalSignature {
} }
impl Debug for InternalSignature { impl Debug for InternalSignature {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Signature( R: {:?}, s: {:?} )", &self.R, &self.s) write!(f, "Signature( R: {:?}, s: {:?} )", &self.R, &self.s)
} }
} }

4
ed25519-dalek/src/signing.rs
View file

@ -543,7 +543,7 @@ impl AsRef<VerifyingKey> for SigningKey {
} }
impl Debug for SigningKey { impl Debug for SigningKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SigningKey") f.debug_struct("SigningKey")
.field("verifying_key", &self.verifying_key) .field("verifying_key", &self.verifying_key)
.finish_non_exhaustive() // avoids printing `secret_key` .finish_non_exhaustive() // avoids printing `secret_key`
@ -742,7 +742,7 @@ impl<'d> Deserialize<'d> for SigningKey {
impl<'de> serde::de::Visitor<'de> for SigningKeyVisitor { impl<'de> serde::de::Visitor<'de> for SigningKeyVisitor {
type Value = SigningKey; type Value = SigningKey;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, concat!("An ed25519 signing (private) key")) write!(formatter, concat!("An ed25519 signing (private) key"))
} }

2
ed25519-dalek/src/verifying.rs
View file

@ -642,7 +642,7 @@ impl<'d> Deserialize<'d> for VerifyingKey {
impl<'de> serde::de::Visitor<'de> for VerifyingKeyVisitor { impl<'de> serde::de::Visitor<'de> for VerifyingKeyVisitor {
type Value = VerifyingKey; type Value = VerifyingKey;
fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, concat!("An ed25519 verifying (public) key")) write!(formatter, concat!("An ed25519 verifying (public) key"))
} }